text:
Where would I start if I wanted to create an AI agent to play a 2d game?
I am keen on creating a little project that can play a fairly basic 2D game (more complex than say, snake but not as complex as mario kart) and would like some pointers on where to begin. I'm entirely new to any coding/programming but have a basic knowledge in machine learning. Is the first step to learn python, or unity? Then from there, what would I look at learning next? Any pointers are appreciated.

Theory
Learn the basic Reinforcement Learning (RL) concepts: Agent, Environment, Action, Reward, Return, Episode, Exploration. Maybe look at Q-Learning, but you don't need to dive deep yet.
Check out the Gymn environments or stable-baselines3. Both are Python libraries used for RL. Look at those for inspiration, not for getting programming experience. It's better to implement something much simpler on your own first.
Programming
If you're new to programming, even a single-player snakes will be a hard challenge. (But a good one, and there are several tutorials.) Interactive games are generally some of the hardest programming challenges.
I advice against Unity3D. Not because it is bad, but because it's too complex. The easiest way to start with programming is with text output. If you're doing a game played entirely by AI, you may even get away without GUI. (Just print the game-world as an array.)
Languages: Python is the natural choice because it's everywhere in machine learning and easy to pick up. C# if you want to use Unity3D later. Rust only if you are serious about investing time into programming. (Avoid C++ for now.) Python, Javascript and C# will all get you faster to something that works.
Step 1: Simple Environment
Some ideas:

A racing-game where everything is a circle (walls, vehicles). Easy to detect collisions. Goal/Reward: going fast.
A grid-world with random stuff lying around (obstacles, apples). Similar to snakes, but without the snake getting longer. Goal/Reward: apples collected.

Don't implement the AI yet. Instead, add an agent that ignores the inputs and makes a random choice every turn.
This will a) get you to something that runs, and b) a baseline score that your AI should beat. It's important to design the game such that random actions can sometimes score a point by chance. This gives the learning algorithm a signal to improve.
Step 2: Machine Learning
Now we need some kind of mapping between the agent inputs (e.g. the 8 neighbours in the grid, or distances to the next obstacle) to outputs (e.g. actions).
Personally I like to implement a neural network for that. It's actually simple (maybe 4 lines of code or so) if you only implement the forward-pass (no back-propagation) and choose the weights at random. With just random search, you should be able to discover weights that beat the baseline score.
Also, it's often better if the outputs are action probabilities (instead of just one action). A common way to do that with neural networks is a softmax layer.
Algorithms:

Random search.

Really. It has been shown that some Atari games can be solved just by trying random weights on a neural network. Worth a shot.
"Random search" is also the name of a specific algorithm, which is not what I mean. The point is to first implement the simplest possible method and debug/simplify until it can make some progress. This builds your understanding how easy/difficult the task is to learn.

Cross-Entropy Method (CEM). Fancy name, but can be simple to implement with basic probability theory (like, just a normal distribution).

Reference: Learning Tetris Using the Noisy Cross-Entropy Method

Evolution strategies have been shown to be competitive with RL algorithms sometimes.
A genetic algorithm. The Microbial GA is one that is easy to implement yourself.
The neuroevolution algorithm NEAT is also popular for this kind of task.
Any real RL algorithm from the stable-baselines3.

I wrote blogpost in 2019 about an experiment in the same spirit.

You can start with Monte Carlo Tree Search to play a 2D game. It is a pretty common algorithm in Reinforcement Learning. If you are comfortable enough with Neural Networks, you can use AlphaZero to create an algorithm to play a 2D game.
Here is a basic implementation of Monte Carlo Tree Search for TicTacToe: https://github.com/nityanandmathur/MCTS

Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers in the help center.

Basic knowledge in machine learning does typically not involve reinforcement learning, which is an ideal choice to make an agent in a video game. Reinforcement learning is famous for beating the simple Atari games, and later beating top players in more complicated games like StarCraft.
A good place to start would be pursuing skills and knowledge in both the field of game development and reinforcement learning. How about two independent courses at sites like Coursera and Udemy? There is probably a course that aims to solve some Atari games, which are avaliable at AI-Gym.
Then it will be trivial to determine if python or unity is right for you.


text:
How to approach a toy classification problem using a neural network?
The toy problem:
50 unique numbers are randomly selected from number 0 to 99.

If number 1 appears in the selection but number 2 doesn't, the selection is labelled as "1".
If number 2 appears in the selection but number 1 doesn't, the selection is labelled as "2".
If both number 1 and number 2 appear in the selection, the selection is labelled as "3".
Lastly, if neither 1 nor 2 appears in the selection, the selection is labelled as "0".
Let's say we want to use a fully connected neural network to classify the selections. The number of input nodes would be 50, which is the number of items in each selection. The number of output nodes will be 4, which will be number of labels/classes. The loss function is cross entry loss which is commonly used in classification problems. The activation function for the hidden layers is ReLU(or leaky ReLU). The question is how do we decide on the number of hidden layers and the number of nodes in each layer? Also let's say we use stochastic gradient descent(SGD) as optimizer, how do we choose the learning rate? Also the training batch size?
I have tried some arbitrary values for those hyper parameters. In some cases the loss doesn't decrease. In some cases the loss decrease to almost 0 for the training data set, but the prediction accuracy for the validation dataset is 25%, which is as good as random guess.Is there any guidelines/heuristics on how to choose those hyperparameters?

Although you label it as a toy system, I see three possible ways to simplify it and get the classifier to start working.

Instead of starting with 50 inputs, start with only 2 inputs.
Instead of considering a range from 0 to 99, start with a smaller range. Since we are to learn a threshold between 2 and 3, a symmetric range would suggest having the numbers in the range 0..5, so the data are not that biased towards the trimmed region.
Instead of viewing this as a classifier, take it as a function approximator: you want the sum of the two inputs when they are different and the maximum when they are the same.

Once we get this small cell to work, we can take at least the following two possible approaches. The basic cell probably needs to have some hidden layer(s) already.
Fully connected. Double the number of inputs while the system works. When it crashes, add an intermediate layer. How many nodes? I guess the ceiling of the square root of the number of input cells, not sure why.
Sparse. Place a basic cell at the output and double the number of cells left-wards, until you can take all your input. For 50 inputs, layers with 32, 16, 8, 4, 2, 1 cells should do the job. Note that as each cell takes two inputs, 32 input cells provide 64 inputs, larger than your required 50. Although this network will be deeper than the fully connected alternative, the number of training parameters is given by the basic cell, so it is actually smaller. I take the idea of doubling the number of cells as a tree from this video by Andrew Ng.
As for the learning rate for the SGD algorithm, you may want to use the default value 0.01. For the batch size, you want to learn a function of two variables with nine possible values after trimming, (0,1,2)x(0,1,2). I think I would start with say 16 data points and double while needed, or start at 10 and multiply by 10. But it still surprises me how much data is needed to learn a simple function, so my starting points are likely too low.
Do you have a Colab notebook with your attempt?

Thanks for your answer. I am still trying to digest your answer and suggestions. But here is the link to colab that I have created for this. https://colab.research.google.com/drive/1vSq-281zUGsvA0tei-E2oDwYu5liiyln?usp=sharing

Ok, thanks! I am more familiar with TensorFlow, but this is a nice opportunity to see some PyTorch. I'll have a look and try some changes asap.

Thanks. No hurry. I am also just starting to learn these libraries, and this tutorial made me decided to go with pytorch. https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html About the suggestion to start with simpler cases, I was thinking if the cases are too simple, say only 2 inputs, there are only a very limited number of input combinations. In this case does it mean that the NN can simply exhaust all the possibilities and "remember" the outputs?

Well... In a sense, it has to remember the outputs, doesn't it? Should it forget the outputs and give wrong results? Maybe I didn't get the aim of your project, but it brings to mind modeling logical functions such as OR, AND and XOR with networks as small as possible.

By "remember" I mean it has seen all the input combinations in the training dataset. In this case the NN just behave like a lookup table?  What we want to do is to use it to predict the output for some inputs that it has not seen before, but hopefully it has extracted certain useful patterns for any inputs in general.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
I'd like some suggestions on how to effectively master machine learning. I'm new to this and I'm kinda lost
Thing is, I got a lot of resources to learn from and I have no idea which ones will be the most effective, and where to start. I've come across 2 kinds of books, the ones which talk about the mathematics behind ML and the others which show the technical side of it with the help of various toolkits. I don't know which to do before which, and I feel like I'm running in circles.
Any suggestions on how I can make my progress effective? Any specific approach with which I need to learn?
P.S. I tend to learn better from books and notes as compared to video lectures, so it would
be really helpful if suggested solutions are along that line.

I think it depends on what you want to do with your knowledge and what background you are coming from. Also are you having any specific problem in mind you want to solve? because that could give a direction.
If you want to come up with new ways of using algorithms for problems, you will probably need to understand the math behind them. so it that is the case you will need to read the first kind of book you mentioned, I think.
if you are just looking to use machine learning for problems that look like ones that have been solved before, you may get away with not knowing the exact math behind it all, as I have been so far (software engineering background).
I started with a book called "Introduction to machine learning with Python" by Andreas C. Müller and Sarah Guido. It is a book that falls under the second category and gives nice implementation examples and tips & tricks. It doesn't cover deep learning though, but is a great introduction.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
How do the "built on ChatGPT" apps work in general at a high level?
I see stuff in my Twitter feed like this every day, showing "ChatGPT used to create X new customized/tailored AI feature".

ColorGPT: Generate a color hex name from real-world color capture from your iPhone.
Castmagic: AI content for podcasts & long-format audio.
AI Gift for you: AI-powered search for gift ideas based on personalized filters.
Cody: ChatGPT with the added benefit of being able to train it on your business, your team, your processes, and your clients with your own knowledge base.
Gitfluence: Helps you quickly find the correct Git command in seconds.
etc..

How are they taking advantage of the ChatGPT API to accomplish these sorts of things (at a high level)? For example, to create the personalized gift filters, how do you go from an arbitrary ChatGPT prompt to stuff specific to products? Or the Gitfluence, how does it tailor ChatGPT to search specifically for git commands?
There is a missing link in my head on how you go from ChatGPT prompt to "AI-feature-based startup hack". Basically, what is that missing link, what do you need to think about to tailor ChatGPT to a specific niche? Roughly how does it work?
I am a software engineer with much experience, so I am aware how to build apps in general, I just don't see what is going on behind the scenes for these sort of "built on ChatGPT" feature apps, or at a high level how it works.

In general, ChatGPT can already solve the problem, and the app provides a user interface to solve a specific problem.
The most important part is the prompt used to query the ChatGPT API.
It defines the question we ask the model, and also the format of the output. The output may be presented in some application specific way.

ColorGPT is a good example of that:
It uses the camera to capture an image, and uses the RGB color code of a color from this image as input for ChatGPT.
ChatGPT can find a color name for a color code, if you query in the right way:
Give me the color name for  #601A35. Only the name.

Output:
The color name for #601A35 is "Dark Raspberry".

The result is not very good in this case, if the prompt would contain a list of color codes and names, it would probably work much better.

On the example with git: ChatGPT knows most shell commands pretty well, it can sometimes reproduce the complete man page if you ask nicely.
For the prompt:
 How do I clone a git repo in a new branch?

I get a full page of explanation, nicely formated.
When I ask for a terse output (with the prompt "Make it terse"), I get:
To clone a Git repository in a new branch:

    Clone the repository: git clone <repository-url>
    Navigate to the repository's directory: cd <repository-directory>
    Create a new branch: git checkout -b <new-branch-name>
    Make changes to the code in the new branch.
    Push changes to the new branch: git push origin <new-branch-name>

This is all with no fine-tuning and basically no prompt engineering.

(As a side note: GPT-4 is used in exactly the same way, and is much more powerful. Scary powerful)

So are they fine-tuning the prompt enough to get back structured data? Or what?

Refining and tweaking the prompt is called prompt engineering. The term fine-tuning refers to fine-tuning the model. You can teach the ChatGPT model application specific data, and then have your own variant of ChatGPT with specific capabilities and/or knowledge. It is run at OpenAI for you, and you use is in the API like the default models. Fine tuning is much more powerful, but also more difficult and expensive, so I assume in almost all cases, prompt engineering is used. You can do a lot with a prompt of about 4000 tokens.

@Lance yes, you can use the prompt to get structured output.

An interesting effect is that if you just asked for the terse git instructions directly you would probably not get such good output. By asking for the full instructions first and then "make it terse" the second step is able to reference the full instructions. I remember reading a paper about this.

@user253751 Good point. There is also the method of appending "Let's think step by step." to the prompt.

@user253751 The result when asking for terse from the start is actually better: The command itself is terse: git clone <repo_url> -b <new_branch_name>


text:
Is it possible for a GPT model to run in a distributed way?
Say that we're on GPT20 - maybe the model that's resulted from training is 10PB large (maybe unlikely but this is an example). Is it possible for a GPT model to be distributed across machines? How does this work if distributed inference is needed?

ChatGPT is already a model of Large neural networks based on a distributed computing platform. ChatGPT was built in collaboration with Microsoft. The model is trained using Azure supercomputing infrastructure with Nvidia GPUs. ChatGPT’s hardware comprises over 285,000 CPU cores, 10,000 GPUs, and network connectivity of 400 GBs per second per GPU server. Information taken from here and here


text:
In which process does filter and watermark take place?
In LLM, in order to avoid discrimination and abuse, the author will add filter and watermark functionalities. Could you tell me in which process these functionalities take place? Is it in weights(pertaining), output layer(transformer), or fine-tuning?
Can I remove the filter by myself if I have an open-source AI like alpaca?

Alpaca:

In LLM, to avoid discrimination and abuse, you can add filters such as
adding noise/jittering to images or applying a watermark on them. This
process typically takes place in the output layer (transformer) of an
AI model. You cannot remove these filter functions by yourself if it
is implemented using closed-source software like Alpaca because then
you won't have access to its source code and will not be able to
modify or replace any existing filters with your own implementations.

GPT 3.5:

The addition of filter and watermark functionalities in LLM typically
takes place during the fine-tuning process, where the model is trained
on a specific task or dataset.
As for removing the filter, it would depend on how the filter was
implemented and whether it can be easily modified or disabled in the
code. If the AI is open-source, you may be able to make changes to the
code to remove the filter functionality, but it would depend on the
specific implementation and any licensing restrictions.

Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers in the help center.


text:
Is it possible to apply entity fixed effects to a firth logit test?
All,
Currently working with a large dataset (~1.6 million observations) with a relatively low number of rare events (~600ish). To summarize, I'm looking at the impact of 7 foreign-policy related independent variables to see the effect on whether a country, in any given year (1816 - 2000), initiates a militarized action against another country (i.e., the outcome variable is binary: either the country attacked or didn't).
Since the binary outcome variable is only 1 in ~600 cases, I'm using a firth logit test, but I think I need to account for country fixed effects. So my question is: does anyone know if it is possible to add entity fixed effects to a firth logit test?
If yes, wonderful! I'd like to add country fixed effects to my model in Stata (version 17). Thanks in advance for any and all insight!


text:
Can I reduce computation by only predicting response tokens in a transformer and still get the same gradients?
I have been looking at the source code of the Stanford Alpaca model and I believe that during inference, the whole instruction + response data is fed into the model normally. Then the instruction part of the label is masked with IGNORE_INDEX to prevent gradient calculation on the instruction.
But I believe that in the transformer network, after the attention blocks and before the last head layer, it should be possible to take only the (embedded) tokens corresponding to the response parts from contexts and avoid predicting from the tokens corresponding to the instruction part altogether. This could potentially save computation, especially when the instruction part is long or when training on back-and-forth conversations, similar to interactions with ChatGPT. So my question is:

Is the gradients calculated by these two approaches the same?

I actually tried to ask GPT-4 about this. Initially, he suggested that my approach would lose some information, but later changed his opinion when I asked him further. Would my approach indeed result in a loss of information or any other drawbacks?

Is the saving, if possible, worth the effort of modifying the model's source code?

Since the change would only affect one matrix multiplication, which is already efficiently computed, I'm unsure if it's worth the trouble. Furthermore, I only know a little bitPyTorch and would definitely struggle with implementing modifications to complicated models written in other frameworks like TensorFlow or JAX.

Hi @Tianchen Zheng, and welcome to AI Stack Exchange! Right now, this post has two separate questions; typically this site requests that only a single question be asked per post. If possible, please edit the post to only have one question. Thank you for posting, and we look forward to seeing you again on this site!


text:
What else beyond convnets is needed to detect sameness in a Bongard problem?
In her book Artificial Intelligence - A Guide for Thinking Humans, Melanie Mitchell explains that convolutional neural networks fail to build a useful model for these two classes of images, yielding chance classification for unseen images.

Image from: https://www.foundalis.com/res/bps/bongard/p057.htm
This surprises me because convolutional networks look very close to the idea embedded in the images: they can detect an object regardless of its position. If splitted in two convenient regions, and taking any of them as a filter, the other region would be perfectly detected in the sameness case, and would yield a low match in the different class.
How should this additional step of splitting be added to the convnet classifier to be able to model sameness?

Thanks. Do you mean attention as in transformers?

Without the splitting, I think that convolving the negative image with itself, then normalizing the maximum wrt the energy of the image, yields about 1/2 for sameness and close to 0 for different.

Yes. So in this scheme (ACNN, autoconvolutional neural networks), one single parameter is to be learned, the threshold to separate classes. This would be translation invariant, but not wrt rotation or size change.


text:
Why does training converges when the norm of gradient increases?

This is from deep learning book by Ian Goodfellow and Yoshua Bengio and Aaron Courville.
When training converges well, I thought the gradient should be at local minima. But the book says it often does not arrive at the critical points. Could you explain me why and how it can occur?
Thank you


text:
How can i tinker my neural network to learn stronger on rare events?
I am training a neural network on a regression problem.
Most of the time the actual y (label) has the same value (say ~0.2) and only in rare cases the actual y is very different (say 2.0 or -2.0)
After training the neural network obviously performs very well on average by allways predicting (predicted y) a number around 0.2, mostly independant on the input.
However, it is still very bad on predicting when the actual y should be different.
At the moment i am improving the situation by training the neural network mostly on situations where y is far from the average y and filtering out situations where y is close to the average y.
Can you think of any better way to make the neural network learn stronger on rare events? (e.g. by using a different cost function other than MSE, ...)
Additional information:
The neural network is supposed to learn the immediate rewards on a reinforcment learning environment.
the nn maps actions+states to the expected immediate reward.
most of the time the immediate reward is the same. (because the agent gets punished on every step it takes)

This seems to be related to the question here, and I stand by my answer there.


text:
LLM-like architecture capable of dynamically learning from its own output
Language Learning Models (LLMs) have demonstrated remarkable capabilities in quick learning during inference. They can effectively grasp a concept from a single example and generate relevant outputs. However, a noticeable limitation of LLMs is their inability to work on large-scale projects, such as generating a cohesive book, due to context size constraints. One potential solution is enabling LLMs to learn from their own outputs, but the learning rate during the training phase is significantly slower than the rate at which they absorb and process concepts during inference.
I am interested in exploring the possibility of an architecture that allows for fast and efficient learning, enabling the AI to dynamically and incrementally train from its own output. This would facilitate the production of large-scale cohesive outputs that surpass context limitations. Although RNNs like RWKV theoretically offer "infinite context size," it is not practically useful as the model tends to "forget" concepts that are distant in the prompt.
Human learning involves continuous adjustments of synapses while working on a problem, which seems like an ideal approach to emulate. Are there any existing or proposed architectures that incorporate this mechanism, allowing for dynamic learning from generated outputs and the creation of large-scale cohesive content in LLMs?

in my (limited) experience, simply re-training an existing tensor model with every exchange ends up by deteriorating previous runs. In other words, a traditional LLM can be trained on the original dataset, then fine-tuned once. What causes this deterioration?

RLHF (Reinforcement Learning through Human Feedback) is quite like your idea. When a model learns from its own outputs, it needs a way to tell if those outputs are good or bad. RLHF uses a method called reinforcement learning to train the model. It checks whether the model's outputs get good feedback (a positive reward) or bad feedback (a negative reward).
This is similar to how humans learn. We tend to do things that make us feel good or get a positive result and avoid things that make us feel bad or get a negative result.


text:
Pedestrian/Object detection
Today automobiles have many kinds of detection systems and I'm currently researching one on Pedestrian Detection systems.
I haven't figured exactly out the difference between these three systems. If anyone experienced on this could give me explonation.

Monocular camera with RADAR
Stereo Camera with RADAR
Stereo Camera.

This far i know, that camera "sees" object, it does it's thing to know if its Human or Car ect.., then RADAR is used to calculate the distance (Dopplers effect).
But when we have Stereo Camera, is this used to also calculate the distance? As it can form 3D pictures?
Or what are the reasons to use Stereo Camera and RADAR together? On Monocular Camera it makes sense becuase it cant measure distance.

Please clarify your specific problem or provide additional details to highlight exactly what you need. As it's currently written, it's hard to tell exactly what you're asking.

Can you please put your specific question in the title?


text:
Is the output of image generation models like Midjourney and Stable Diffusion deterministic?
Assuming the user can set all parameters, including but not limited to the seed.
Is the output deterministic? As in, the same set of inputs will create the same image?

Yes.
By setting the seed you can control the reproducibility. See the Guide to using seed in Stable Diffusion

With all parameters fixed except for the seed, the output will have some degree of randomness.
Using the prompt "dogs chasing cars in Alaska" three times I got the following on Stable Diffusion v1.5:

Even with all parameters fixed, I have gotten slightly different results with SD 1.4 at least when generating a batch of images. I haven't done extensive testing on this, but even a single sample is sufficient to show that the results weren't identical. The used code is a private fork from neonsecret/stable-diffusion.
Eight of the nine images were pretty much identical, but for some reason the middle row's right image showed some variation between runs on the hand. I also tried running a single image once, and this time the result was identical.
SD 1.4, "Indian girl on a flower field, digital art, realistic, highly detailed, concept art", CFG 3, 50 steps, seed 2347886331, DDIM sampler.
The gamma of difference images was set to 3.0 in GIMP, to enhance small deviations.

Actually it would be better to run a larger batch of identical seeds and see whether they are identical or not. I did these via copy-paste from a free SD website I run. It would be interesting to know if these results can be reproduced on different code-bases. My fork deviates quite a lot from the original one, due to several extra optimizations.
Edit 1: The image comparison is done on lossy-compressed WebP images, with a quality setting of 95%.

It depends.
It is reproducible on the same hardware, but if you try running on different operating systems or different Torch devices (CPU and CUDA, CUDA and MPS), the results are not the same.

Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers in the help center.


text:
Best calculus books for Deep Learning
Recommend some calculus books for Deep Learning and neural networks. I know what is integration, differentiation, derivates, limits on a based level. I would like to understand on deep level the calculus behind Deep Learning and neural networks.

Quite a broad question, but I think we should have some sort of community wiki to handle such queries. But check out Ian Goodfellow's book on the same. It is a must read.

The first chapters of "Deep learning", by Goodfellow, Bengio and Courville, focuses on math, mostly linear algebra and calculus.


text:
What is a Markov chain and how can it be used in creating artificial intelligence?
I believe a Markov chain is a sequence of events where each subsequent event depends probabilistically on the current event.  What are examples of the application of a Markov chain and can it be used to create artificial intelligence?  Would a genetic algorithm be an example of a Markov chain since each generation depends upon the state of the prior generation?

A Markov model includes the probability of transitioning to each state considering the current state. "Each state" may be just one point - whether it rained on specific day, for instance - or it might look like multiple things - like a pair of words. You've probably seen automatically generated weird text that almost makes sense, like Garkov (the output of a Markov model based on the Garfield comic strips). That Coding Horror article also mentions the applications of Markov techniques to Google's PageRank.
Markov models are really only powerful when they have a lot of input to work with. If a machine looked through a lot of English text, it would get a pretty good idea of what words generally come after other words. Or after looking through someone's location history, it could figure out where that person is likely to go next from a certain place. Constantly updating the "input corpus" as more data is received would let the machine tune the probabilities of all the state transitions.
Genetic algorithms are fairly different things. They create functions by shuffling around parts of functions and seeing how good each function is at a certain task. A child algorithm will depend on its parents, but Markov models are interested mostly in predicting what thing will come next in a sequence, not creating a new chunk of code. You might be able to use a Markov model to spit out a candidate function, though, depending on how simple the "alphabet" is. You could even then give more weight to the transitions in successful algorithms.

(this was intended as a comment, but turned out long and longer)

A couple of points to elaborate on Ben's answer:

It is possible to generate different models (out of existing data!) and then look for the model that best fit new data (e.g. with knn). Example:

States = {sleep, eat, walk, work}
Model 1: Most probable sequence on weekdays, say: sleep → sleep → eat → walk → work → work → eat → walk → sleep  → sleep
Model 2: Most probable sequence on weekends, some: sleep → sleep → eat → walk → eat → walk → sleep → sleep
New data arrives: Which sequence is more probable that it came from? Check model 1, check model 2. Which fits better? → Assign

Note that the previous example is oversimplified. Also note that a unit time is needed there (other than letters / words, for instance).
You can nest Markov models. That means that you generate a model (a set of probabilities for all the states) in a "lower scale" and then use it in a more abstract model. For example, you can nest your day-scale model to a month or year (to include holidays, for instance).

Also see this link for a nice introduction and some posts in crossvalidated.

As for the question if artificial intelligence can be created by using this kind of methods, my personal (easy) answer would be no, because they only relate data and probabilities and thus belong more to the statistics and machine learning branch.
A longer answer needs to take into account the weak vs. strong AI question.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
How does Knowledge Distillation help Federated Learning?
As per my understanding, typically in FL, there is a global server that interacts with various client devices. The global server and the client both possess a ML models. The client(s) update their models locally and then send the weights across to the server where it is averaged.
The paper, Communication-Efficient On-Device Machine Learning: Federated Distillation and Augmentation under Non-IID Private Data, has the following paragraph - "To rectify this, each device in FD stores per-label mean logit vectors, and periodically uploads these local-average logit vectors to a server. For each label, the uploaded local-average logit vectors from all devices are averaged, resulting in a global-average logit vector per label."
I am really lost with what one can do with "mean logit vectors" of a label. According to me, that's like saying, a dataset consists of 2 labels with the first label coming up 40% of the time and the second 60%. How does this help with prediction? Perhaps my understanding is wrong here.

The logit vectors in the aforementioned paper are actually the outputs of the models and not the reference values in the dataset:

Each model output is a set of logit values normalized via a softmax
function, hereafter denoted as a logit vector

The average here serves as a proxy for communication efficient comparison of "teacher" and "student" outputs.


text:
What are the advantages of complex-valued neural networks?
During my research, I've stumbled upon "complex-valued neural networks", which are neural networks that work with complex-valued inputs (probably weights too). What are the advantages (or simply the applications) of this kind of neural network over real-valued neural networks?

According to this paper, complex-valued ANNs (C-ANNs) can solve problems such as XOR and symmetry detection with a smaller number of layers than real ANNs (for both of these a 2 layer C-ANN suffices, whereas a 3-layer R-ANN is required).
I believe that it is still an open question as to how useful this result is in practice (e.g. whether it actually makes finding the right topology easier), so at present, the key practical advantage of C-ANNs is when they are a closer model for the problem domain.
Application areas are then where complex values arise naturally, e.g. in optics, signal processing/FFT or electrical engineering.

What precludes applications in domains where complex values don't arise "naturally"?

@dynrepsys To the best of my knowledge, nothing, although having complex inputs in a real  valued domain would seem an odd design choice.

Could they be used in weights without being used as inputs?

@dynrepsys I believe so.

Just a side note - implementing complex-valued weights and activations is certain platforms and languages can be awkward, since many lack support for complex-valued data types. In some, such as C#, VB.net, T-SQL and others I'm familiar with, various workarounds are available like using structs, classes and user-defined types (UDTs) but it's usually just not the same as having built-in data type support. Personally I've found it easier to model complex weights and activations by simply using two (or more) real-valued data types, one for each axis. YMMV though, depending on the application...

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Can we prove that a piece of code in AI software will cause it to never turn against us?
It is possible of normal code to prove that it is correct using mathematical techniques, and that is often done to ensure that some parts are bug-free.
Can we also prove that a piece of code in AI software will cause it to never turn against us, i.e. that the AI is friendly? Has there any research been done towards this?

Unfortunately, this is extremely unlikely.
It is nearly impossible to make statements about the behaviour of software in general. This is due to the Halting problem, which shows that it is impossible to prove whether a program will stop for any given input. From this result, many other things have been shown to be unprovable.
The question whether a piece of code is friendly, can very likely be reduced to a variant of the halting problem.
An AI that operates in the real world, which is a requirement for "friendliness" to have a meaning, would need to be Turing complete. Input from the real world cannot be reliably interpreted using regular or context-free languages.
Proofs of correctness work for small code snippets, with clearly defined inputs and outputs. They show that an algorithm produces the mathematically right output, given the right input.
But these are about situations that can be defined with mathematical rigour.
"Friendliness" isn't a rigidly defined concept, which already makes it difficult to prove anything about it. On top of that, "friendliness" is about how the AI relates to the real world, which is an environment whose input to the AI is highly unpredictable.
The best we can hope for, is that an AI can be programmed to have safeguards, and that the code will raise warning flags if unethical behaviour becomes likely - that AI's are programmed defensively.

Just because it's impossible to make general statements doesn't mean that verification of properties isn't possible for many types of system.

In practice, the problem arises not because of we don't know how to verify complex systems (which can, at least in principle, be addressed methodologically) but because of the difficulty in formalizing 'friendly'.

@user217281728 I've updated the answer in the light of your first comment. Indeed there are many subclasses that we can make statements about, like the context-free languages. But these are too limited to form an AI that operates in the real world.

I'm not sure that there's any language (provably halting other otherwise) that can readily formalize a concept as ill-defined as 'friendly', so in practice, we agree. As per my answer, my hope is that it might be able to make defensive inroads into the formalization problem via obligation calculii...

Here are some examples of recent work on verifying certain properties of autonomous systems [RoboCheck].
However, to achieve the same kind of thing for the notion of 'friendly' using formal verification (i.e. 'proving correctness using mathematical techniques'),
it would (at the least) seem necessary to be able to express 'friendly' within a logical formalism, (i.e. as a predicate testable within a model-checker, so that we can be sure a system never enters an undesirable state).
However, it's not immediately clear that 'friendly' has a more specific definition than 'a desire not to harm humans', so much more low-level detail is needed.
Some previous work in this general area that might be useful in this respect include:

Deontic Logic - a logical calculus of obligations.
Elephant 2000 - John McCarthy's description of a promise-based programming language.


text:
How Watson can help to make medical diagnoses?
On Watson wiki page we can read:

In healthcare, Watson's natural language, hypothesis generation, and evidence-based learning capabilities allow it to function as a clinical decision support system for use by medical professionals.

How exactly such AI can help doctors to diagnose the diseases?

Watson can make its diagnosis based on the patient's data and comparing it to the data from millions of other studies.
For example, having enough genetic data and the right algorithms, its AI computing capability demonstrated the huge potential of data analysis based on which it can be used for everything from diagnosing rare illnesses to prescribing perfect dosages of medicine based on the patient's personal genetic makeup. Of course, there are still plenty of challenges that need to be overcome before it can be used in mainstream medicine.
Recently Watson was able to diagnose a rare form of leukaemia after treatment was proved ineffective. It was fed in with the patient’s genetic data and compared to data from other 20 million oncological studies.
Sources:

Artificial Intelligence Used To Detect Rare Leukemia Type In Japan (2016)
Watson correctly diagnoses woman after doctors were stumped (2016)


text:
What kind of body (if any) does intelligence require?
In the mid 1980s, Rodney Brooks famously created the foundations of "the new AI". The central claim was that the symbolist approach of 'Good Old Fashioned AI' (GOFAI) had failed by attempting to 'cream cognition off the top', and that embodied cognition was required, i.e. built from the bottom up in a 'hierarchy of competances' (e.g. basic locomotion -> wandering around -> actively foraging) etc.
I imagine most AI researchers would agree that the 'embodied cognition' perspective has now (at least tacitly) supplanted GOFAI as the mainstream.
My question takes the form of a thought experiment and asks: "Which (if any)  aspects of 'embodied' can be relaxed/omitted before we lose something essential for AGI?"

This is something of an orthogonal answer, but I think Brooks didn't go about his idea the right way. That is, subsumption architecture is one in which the 'autopilot' is replaced by a more sophisticated system when necessary. (All pieces receive the raw sensory inputs, and output actions, some of which turn off or on other systems.)
But a better approach is the normal hierarchical control approach, in which the target of a lower level system is the output of a higher level system. That is, the targeted joint angle of a robot leg is determined by the system that is trying to optimize the velocity, which is determined by a system that is trying to optimize the trajectory, which is determined by a system that is trying to optimize the target position, and so on.
This allows for increasing level of complexity while maintaining detail and system reusability.

That said, I don't think you actually need what one would naively call 'embodied cognition' in order to get the bottom-up hierarchy of competencies that Brooks is right to point towards. The core feature is the wide array of inputs and outputs, which are understood in a hierarchical fashion that allows systems to be chained together vertically. I think you could get a functional general intelligence whose only inputs and outputs involve going through an Ethernet cable, and doesn't have anything like a traditional body that it actuates or senses through. (This is a claim that the hierarchical structure is what matters, not the content of what we use that structure for.)
(The main place to look for more, I think, is actually a book about human cognition, called The Control of Perception by William T. Powers.)

Completely agree, and would like to add that most of those ideas were generated before 1990s, before most of modern IT technologies came to existence. Currently it is not unthinkable to imaging nice virtual environment with extensively detailed surroundings, so that AI would not required to be in physical body. Even if it will not be contained in closed virtual world, it will be possible to create such a massive stream of information via multiple channels like web-cams, microphones and numerous APIs, so AI would have enough information to build world model.


text:
Is recursion used in practice to improve performance of AI systems?
Is there any methods by which artificial intelligence use recursion(s) to solve a certain issue or to keep up working and calculating?

Can you clarify the phrase 'keep up working and calculating'?

To my knowledge, recursion does not play a strong role in the definition of modern AI techniques, although it does feature used in Lovasz's definition of 'Local Search' and Kurzweil is certainly an advocate.
Recursion can be seen as an elegant 'architectural factorization' - building complexity by combining the results of smaller, similar patterns previously encountered. Computationally, recursion can always be converted into iteration so this form of elegance is really mainly of use in helping to make designs more comprehensible.
GOFAI algorithms that were traditionally defined using recursion include depth- and breath- first search and means-ends analysis (used in Newell and Simon's General Problem Solver).
With respect to performance, while many functions can be very economically defined using recursion, the naive version of such definitions can be inefficient.
This page gives an example in which recursive version of the Fibonacci function, which has asymptotic execution time $n^{1.6}$, which is reduced to $n$ by the use of memoization.

It's important to note that some languages like Prolog use recursion as one of the main methods of handling parse trees - this is considered powerful when it comes to handling NLP and applications like Watson make use of this property.


text:
How to classify language as friendly or aggressive with AI?
Just for the purpose of learning I'd like to classify the likeliness of a tweet being in aggressive language or not.
I was wondering how to approach the problem. I guess I need first train my neural network on a huge dataset of text what aggressive language is. This brings up the question where I would get this data in the first place?
It feels a bit like the chicken and egg problem to me so I wonder how would I approach the problem?

The answer by Cem Kalyoncu mentions the difficulty of building a ground truth database for aggressiveness.
One alternative approach would be to attempt to operate at the concept level, which would allow the use of pre-existing ontologies such as ConceptNet.
Here's a paper that describes this technique.

That's interesting indeed. ConceptNet has a really cool API. I'm not sure if it's worth for me to pursue the idea since I'm really just trying to find ideas to explore to make myself familiar with AI but thank you very much for raising awareness!

I did a little search and couldn't find any database that has ground truth for aggressiveness. This means that you need to build yourself a database. This might be huge undertaking. Take thousands of messages, and classify them by hand whether they are aggressive or not. This part is quite labor intensive.
Second part is much easier at start but would be pain to optimize (both performance and computational cost). I would suggest you to start with Naive Bayes classifier for this job. That is the preferred classifier for spam detection. ANN would probably not work for this case because the data would be a huge sparse vector. Estimated number of words in English is over a million, which means the input layer of your ANN should be able to scale up to that number. Search for sparse vector classification for additional classifier that can be used in these cases.

Thank you very much for answer. I wasn't sure if I'm totally off and miss the forest for the trees. I probably just pick a different use case for me to play with then :)

A simple way to do it would be lexicograpical sentiment analysis.  To do that, you'd need a list of words categorized with a score that reflects "friendly" vs "aggressive" sentiment.   For an example of setting up a SA system using Spark, see this article.  To do what you're talking about, substitute AFINN for a different dataset.  You might have to create said dataset yourself, if there isn't one "out there" like you want.
Note that this isn't the most sophisticated technique in the world, but it's been found to be surprisingly effective.

I would completely agree with mindcrime and Cem Kalyoncu.
Take into account that passive agressiveness for example is more difficult to detect (irony, black humour, sarcasm likewise)
Although another head start could be to think out of the box:
Happens by chance that I have lying around a book concerning violent-free communication. So probably your best start could be to talk with linguists about violence in language and start from there. or just make some reviews about how linguists or psychlogists detect violence in language (susprise: It's probably quite complex)
Nevertheless: I don't think you need real AI, a blacklist of words and expressions together with some pattern detection for expressions could be precise enough for the beginning.
Then for all the expressions, words, etc. you could add a bayesian network for the learning part, which works with probablities (like e.g some email spam filters)
Search for example for "Naive Bayes spam filtering"
This should be pretty much enough to have a good start, so in strict sense, you don't need real AI here, just BusinessIntelligence and probability calculations.


text:
What are the main problems hindering current AI development?
I have a background in Computer Engineering and have been working on developing better algorithms to mimic human thought. (One of my favorites is Analogical Modeling as applied to language processing and decision making.) However, the more I research, the more I realize just how complicated AI is.
I have tried to tackle many problems in this field, but sometimes I find that I am reinventing the wheel or am trying to solve a problem that has already been proven to be unsolvable (ie. the halting problem). So, to help in furthering AI, I want to better understand the current obstacles that are hindering our progress in this field.
For example, time and space complexity of some machine learning algorithms is super-polynomial which means that even with fast computers, it can take a while for the program to complete. Even still, some algorithms may be fast on a desktop or other computer while dealing with a small data set, but when increasing the size of the data, the algorithm becomes intractable.
What are other issues currently facing AI development?

we don't really know what intelligence is.
we don't truly understand the best model of intelligence we have available (human intelligence) works.
we're trying to replicate human intelligence (to some extent) on hardware which is quite different from the hardware it runs on in reality.
the human brain (our best model of intelligence) is mostly a black-box to us, and it's difficult to probe/introspect its operation without killing the test subject.  This is, of course, unethical and illegal. So progress in understanding the brain is very slow.

Combine those factors and you can understand why it's difficult to make progress in AI. In many ways, you can argue that we're shooting in the dark. Of course, we have made some progress, so we know we're getting some things right. But without a real comprehensive theory about how AI should/will work, we are reduced to a lot of trial and error and iteration to move forward.

I am assuming by AI you mean AG(eneral)I, not machine learning or expert systems tuned for specific tasks.
In addition to @mindcrime's answer, sometimes we run out of samples to train and sometimes computers became so slow to process enough samples to work in manageable timescales. @bpachev mentioned memory but on the surface, our supercomputers have more than enough memory to store a human brain matrix. But we lack the ability to simulate it real time. After we are able to do that, we also need to connect external input, even more processing power is required for that. Even that would not be enough to simulate a human brain fully as biochemistry plays an important role.
One final note would be there is little incentive to develop AGI other than understanding how the human mind works. There are classification algorithms, expert systems, knowledge engines that can out-perform even the best humans for specific tasks.

Regarding your last note, you seem to imply that understanding the human mind and human cognition is of little value outside of itself. Couldn't AGI systems be used to help treat patients with considerable brain damage and memory loss or with interacting the brain with mechanical appendages? It seems that if we can create a truly genuine AGI, we will have answered one of the questions that has plagued mankind for millennia and would have countless applications outside of just an intellectual pursuit.

But I do agree with you that specialized expert systems are invaluable resources to us apart from creating AGI.

Understanding how human mind works is not only intellectual pursuit, it has medical implications as you stated. But, not just brain damage and memory loss, but psychological as well. Solving PTSD or OCD will have great positive effect on society. On the other hand, it will have military applications. Why interrogate someone when you can extract the info from their brain, right?

This seems like a great topic for another question: What are the ethical implications for creating a genuine AGI?

One obstacle to the development of AI is the fundamental limitations of computer memory. Computers, at a fundamental level, can only work with bits. This limits the type of information that they can describe.
EDIT:
The precise nature and complexity of human memory isn't fully understood, but I would argue that at the very least, human memory is well adapted for the types of tasks that humans perform. Thus, computer memory, even if theoretically capable of representing everything that human memory can, is  probably inefficient and poorly structured for such a task.

Neoromorphic memory indexing schemes, such as Kanerva's 'Sparse Distributed Memory', have been around for a while.

You'd have to be more specific about what you mean with "The human brain encodes information with chemicals". Information is encoded in the brain through changes in the neurons connections to one another and not through the neurotransmitters themselves. However in the end it can be loosely modeled as being a single "weight" value per connection, thus the idea that chemicals encode information in a more complicated fashion than bits would appear to be incorrect.

@tomzx Thanks for your feedback. It was my understanding that human memory isn't well understood, but that due to the chemical nature of the brain, memory was represented chemically. I'll edit my answer to be less speculative.


text:
What are the benefits of the VGDL over the ALE?
For benefits of testing AGI, is using a high-level video game description language (VGDL) gives more reliable and accurate results of general intelligence than using Arcade Learning Environment (ALE)?

Here is a description of the input to an ALE agent:
Percept state: A single game screen (frame): a 2D array of 7-bit pixels, 160 pixels wide by 210 pixels high.
Actions: 18 discrete actions defined by the joystick controller
Regarding VGDL, as far as I can see, the main site associated with it is gvgai.net, which is currently down. The associated API is described in this paper.
Percept state for GVGAI is more structured than for ALE, but the closest correspondence to ALE appears to be an 'Observation grid', consisting of a 2D array of sprite identifiers.
Actions: ACTION_NIL, ACTION_UP, ACTION_LEFT, ACTION_DOWN, ACTION_RIGHT and ACTION_USE (stated as 'typical' values).
Of the two, it would seem that ALE is more suitable for AGI, because of the more 'free form' nature of the input.
However, one of the issues with either of these approaches is that the set of possible actions is strongly constrained. These domains are therefore 'operationalised' - the hard task of working out what actions are possible has already been solved for the AI by the API, effectively acting as a bottleneck on the complexity of mapping from input to output.
A range of alternative game-playing frameworks are listed here and one alternative (which I personally believe is more useful for AGI purposes) is the Artificial Text Adventurer, in which (at each turn) agent is presented with natural language input describing the scene and must then output a command in natural language. Disclaimer: I am associated with this competition.


text:
Which neural network has capabilities of sorting input?
I believe normally you can use genetic programming for sorting, however I'd like to check whether it's possible using ANN.
Given the unsorted text data from input, which neural network is suitable for doing sorting tasks?

Even a simple multilayer perceptron can sort input data to some extent, as you can see here and here.
However, neural networks for sequential data seem more appropriate, as they can handle sequences of variable lengths. It has been done with an LSTM (Long Short-Term Memory), LSTM+HAM (Hierarchical Attentive Memory) and an NTM (Neural Turing Machine).

You should look at pointer networks. It is still not perfect for the case, but it should be more applicable than LSTMs and MLPs because they learn in an output space of size equal to the input, rather than a fixed input dim that you would get using LSTMs in sequence to sequence or direct MLP. By design though they are meant for problems with replacement. Sorting when done sequentially is without, so to remedy this in the case of a pointer network, you could mask outputs that have already been chosen before the final normalization step (such as softmax)


text:
Is Prolog still used in AI?
According to Wikipedia,

Prolog is a general-purpose logic programming language associated with artificial intelligence and computational linguistics.

Is it still used for AI?

This is based off of a question on the 2014 closed beta. The author had the UID of 330.

Remembering that artificial intelligence has been an academic endeavour for the longest time, Prolog was amongst one of the early languages used as part of the study and implementation of it. It has rarely made its way into large commercial applications, having said that, a famous commercial implementation is in Watson, where prolog is used for NLP.
The University of Edinburgh contributed to the language and it was sometimes referred to as "Edinburgh Prolog". It is still used in academic teachings there as part of the artificial intelligence course.
The reason why Prolog is considered powerful in AI is because the language allows for easy management of recursive methods, and pattern matching.
To quote Adam Lally from the IBM Thomas J. Watson Research Center, and Paul Fodor from Stony Brook University:

the Prolog language is very expressive allowing recursive rules to represent reachability in parse trees and the operation of negation-as-failure to check the absence of conditions.

Yes, as mentioned in other answers, Prolog is actually used in IBM Watson.  Prolog doesn't get much "hype" and "buzz" these days, but it is absolutely still used.  As always, it has certain specific areas where it shines, and specific techniques that map well to its use.  Specifically, things like Inductive Logic Programming, Constraint Logic Programming, Answer Set Programming and some NLP applications may involve extensive use of Prolog.


text:
What are the minimum requirements to call something artificial neural network?
I've found this short Python code which implements neural network in 11 lines of code:
X = np.array([ [0,0,1],[0,1,1],[1,0,1],[1,1,1] ])
y = np.array([[0,1,1,0]]).T
syn0 = 2*np.random.random((3,4)) - 1
syn1 = 2*np.random.random((4,1)) - 1
for j in xrange(60000):
    l1 = 1/(1+np.exp(-(np.dot(X,syn0))))
    l2 = 1/(1+np.exp(-(np.dot(l1,syn1))))
    l2_delta = (y - l2)*(l2*(1-l2))
    l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1))
    syn1 += l1.T.dot(l2_delta)
    syn0 += X.T.dot(l1_delta)

I believe it may be a valid implementation of neural network, but how do I know?
In other words, is just creating bunch of arrays which compute the output on certain criteria and call them layers with synapses does it make proper neural network?
In other words, I'd like to ask, what features/properties makes a valid artificial neural network?

If you pick up a textbook on Neural Networks, you'll find that the simplest examples shown are ones that just implement an AND gate or something.  They're trivial, probably fewer lines of code than what you have there.  The bar to be an "artificial neural network" is pretty low... it certainly isn't the case that ANN's must be incredibly complicated with thousands of lines of code, and many layers, or even many "neurons" total.
Basically, if something is setting up at least one "neuron" with multiple inputs, and using some kind of weighting function to generate an output from those inputs, it's a valid ANN. It might be a really simple example of an ANN, but it's still an ANN.
Remember what Geoffrey Hinton says in his Coursera class - (paraphrased) "We don't pretend that the things we're building really work the way the brain does, we're just taking the brain as loose inspiration for an approach that we've found works".

Could you link to the mentioned coursera class?

Maybe. I think that is one of the ones that got deleted, and I'm not sure if the new Neural Networks class has the same video content or not.  But if I can scour up a link, I'll drop it here.

If you've some dead link, double check on http://web.archive.org. Maybe the course is mirrored somewhere, like on YouTube or somewhere.


text:
Research for misbehavior detection in WiFI networks
I'm looking for research which discusses misbehavior detection in public internet access networks using ANN approaches.
So it can be used by ISP to detect suspicious users connected to their network.

One popular technique for doing this is to use Artificial Immune Systems, an evolutionary computation approach which maintains a population of pattern detectors.
Here is a survey paper.


text:
Given enough computational resources, do we currently have any algorithms which could achieve AI?
Hypothetically, assume that you have access to infinite computing power. Do we have designs for any brute-force algorithms that can find an AI capable of passing traditional tests (e.g. Turing, Chinese Room, MIST, etc.)?

Note, I do not intend to include infinite man power (e.g. checking if a solution passes such tests by hand) in the hypothetical. Evaluation should be computational until a solution is proposed.

properly implemented genetic algorithm

evaluated how? What is the heuristic?

What 'infinite' means here could possibly be debated at some length, but that notwithstanding, here are two conflicting answers:
'Yes': Simulate all possible universes. Stop when you get to one containing a flavor of intelligence that passes whatever test you have in mind. Steven Wolfram has suggested something broadly along these lines. Problem: the state of computational testing for intelligence e.g. Winograd schema would then be the bottleneck. In the limit, testing for intelligence requires intelligence and creativity on behalf of the questioner.
'No': It may be that, even with infinite ability to simulate, there may be some missing aspect of our simulation that is necessary for intelligence. For example, AFAIK quantum gravity (for which we lack an adequate theory) is involved in Penrose's "Quantum Microtubules" theory of consciousness (*). What if that was needed, but we didn't know how to include it in the simulation?
The reason for talking in terms of such incredibly costly computations as 'simulate all possible universes' (or at least a brain-sized portion of them) is to deliberately generalize away from the specifics of any techniques currently in vogue (DL, neuromorphic systems etc). The point is that we could be missing something essential for intelligence from any of these models and (as far as we know from our current theories of physical reality) only empirical evidence to the contrary would tell us otherwise.
(*) No-one knows if consciousness is required for Strong AI, and physics can't distinguish a conscious entity from a Zombie.

We're definitely nowhere near that level of AI; at best, high-tech solutions like deep convolutional neural nets can help with image recognition and some other algorithms can perform things like robotic movement adequately enough to be useful in some scenarios. None of this is even as sophisticated as the behavior of a flea, but no one refers to insects as "intelligent." It's exciting stuff that allows us to solve problems that human intelligence often has difficulty with (such as classification of thousands of objects, which would tire an ordinary human mind), but it's nowhere close to replicating our higher brain functions.
Also keep in mind that the Turing test is a poor test of "intelligence" that defies common sense. By the same extension, mistaking a mannequin for a human being in the dark does not mean that the mannequin is actually human. If it were a valid test, then we passed that way back around 1980 with programs like Dear Eliza which were coded in BASIC to regurgitate human speech patterns. There's just no need to come up with a sophisticated argument like Searle's Chinese Room to debunk it, since it's silly on its face; any layman should be able to see right through the Turing Test. If anyone except Turing had come up with this test it would not have received much attention. Turing displayed one-of-a-kind genius when it came to things like computing and cryptography, but like many other experts in such fields, he had a lot of trouble grappling with metaphysics and philosophy. Searle had more common sense, but his Chinese Room example is more of a rebuttal to the Turing Test than a test in and of itself.
What "intelligence" consists of is ultimately a deep metaphysical question, not a material one. For millennia, trained philosophers have had a lot of trouble assigning clear definitions to concepts like intelligence and consciousness. Until we can answer those questions definitively, using different sets of reasoning skills than scientists, mathematicians and computer specialists are used to employing (just look at how often metaphysics is derided in some of these disciplines) then we cannot say that we have achieved genuine A.I. Until we can define what intelligence is, we cannot say whether or not we've successfully built it; we've not only got the cart before the horse, but have yet to build the cart or see a horse. By the common definitions used in everyday speech we're nowhere near genuine A.I. No one calls cows or sparrows "intelligent," but our AI today isn't even as sophisticated as the mosquitoes that bite them.
That's not going to be a popular answer - I'll probably get a dozen downvotes for this, without anyone being able to adequately rebut my contentions, but it needs to be said. There's far too much irrational exuberance and gross overestimation of what we've achieved to date and probably always will be in this field. Historically, researchers in every generation have also grossly underestimated the computing power of the human brain; every decade or so, the estimates of the FLOPS and megabytes have to be drastically revised. We have a poor track record of even getting basic material questions about the human brain right. This clear, consistent pattern of biased overestimation of our success and the lack of any real definition, let alone a test, of intelligence is going to be a serious issue in this forum for its whole existence (assuming it survives the private beta period). We have a whole forum dedicated to a field we can't even define; we can't say for sure what A.I. really is, but we're adamantly certain that we're close to achieving it...!  We cannot say if "brute force algorithms" exist when we're still groping for an understanding of what it is we're trying to force our way into. Certainly, there are brute force methods to solve certain problems, like Deep Blue does at chess - but we cannot say if that qualifies as intelligence or not. It is really not possible to answer questions like this without getting into deep discussions that immediately lend themselves to opinion and debate, which the Turing Test and Searle's Room are clear examples of, in and of themselves. Since implementation details of AI are considered by many to be off-limits here, we're limited mainly to highly speculative posts about tech that often doesn't even work yet (like Google's self-driving cars) and questions like this that we can't answer without first defining intelligence. This is going to be the root of a lot of problems here for a long, long time to come...

lol uh "a mannequin in the dark" is a far cry from something that has learnt how to behave so realistically it could fool you into believing its a living human being. Also "without anybody being able to adequately rebut my contentions" is pretty contentious man. Anyways by your reasoning since intelligence isn't defined then how can you argue humans are intelligent, this is just another liberty you have taken that I find to be incredibly biased whether it is intentional (simply trying to justify your stance) or not (you actually believe this) i cannot say.

Infinite computational power in the absence of training data implies nothing beyond the ability to solve equations.  In order to implement a behavior, criteria of success and failure are essential.  A small bootstrap loss function with an adaptive feedback loop allowing its elaboration, infinite training data, and AIXI or Solomonoff induction would suffice, in principle, given your premise of infinite computational power.  In fact, it would occur precisely as fast as the input data rate permitted.  In practice, such general approaches require exponential time and space, and are thus intrinsically quite limited in application, absent some kind of efficiency hack.  (Where 'efficiency hack' probably encompasses entire sciences, industries, and generations of research, and the resulting adaptation doesn't look much like, e.g., AIXI at all, in the end.)


text:
How does using ASIC for the acceleration of AI work?
We can read on Wikipedia page that Google built a custom ASIC chip for machine learning and tailored for TensorFlow which helps to accelerate AI.
Since ASIC chips are specially customized for one particular use without the ability to change its circuit, there must be some fixed algorithm which is invoked.
So how exactly does the acceleration of AI using ASIC chips work if its algorithm cannot be changed? Which part of it is exactly accelerating?

No mainstream AI technique that I'm aware of requires modification of the algorithm, though most are dependent on the ability to modify data (connection strengths, population members) etc.

So the only dynamic part like state of network is kept on some flash memory or drive?

According to https://en.wikipedia.org/wiki/Application-specific_integrated_circuit, modern ASICs can have RAM...

Tensor operations
The major work in most ML applications is simply a set of (very large) tensor operations e.g. matrix multiplication. You can do that easily in an ASIC, and all the other algorithms can just run on top of that.

An important point is that the TPU uses 8 bit multiplication, which can be implemented much more efficiently than wider multiplication offered by the CPU. Such a low precision is sufficient and allows to pack many thousands of such multipliers on a single chip.

I think the algorithm has changed minimally, but the necessary hardware has been trimmed to the bone.
The number of gate transitions are reduced (perhaps float ops and precision too), as are the number of data move operations, thus saving both power and runtime.  Google suggests their TPU achieves a 10X cost saving to get the same work done.
https://cloudplatform.googleblog.com/2016/05/Google-supercharges-machine-learning-tasks-with-custom-chip.html

Low precision enables high parallelism computation in Convo and FC layers.
CPU & GPU fixed architecture, but ASIC/FPGA can be designed based on neural network architecture


text:
How good is AI at generating new, unseen [visual] examples?
By new, unseen examples; I mean like the animals in No Man's Sky.
A couple of images of the animals are:

So, upon playing this game, I was curious about how good is AI at generating visual characters or examples?

We are getting pretty good at image generation, some examples:

Radford, Alec, Luke Metz, and Soumith Chintala. "Unsupervised representation learning with deep convolutional generative adversarial networks." arXiv preprint arXiv:1511.06434 (2015). https://arxiv.org/pdf/1511.06434.pdf
Gregor, Karol, Ivo Danihelka, Alex Graves, Danilo Jimenez Rezende, and Daan Wierstra. "DRAW: A recurrent neural network for image generation." arXiv preprint arXiv:1502.04623 (2015). https://arxiv.org/pdf/1502.04623.pdf

From (1):

Then there is another research direction around  evolutionary algorithms, for example:

Sims, Karl. "Evolving virtual creatures." In Proceedings of the 21st annual conference on Computer graphics and interactive techniques, pp. 15-22. ACM, 1994. https://scholar.google.com/scholar?cluster=6031059536657676358&hl=en&as_sdt=0,22 ; https://www.youtube.com/watch?v=bBt0imn77Zg


text:
Have any AI systems yet been developed that can knowingly lie to / deceive a human?
AI systems today are very capable machines, and recently the area of Natural Language Processing and Response has been exploding with innovation, as well as the fundamental algorithmic structure of AI machines.
I am asking if, given these recent breakthroughs, have any AI systems been developed that are able to (preferably with some measure of success) knowingly lie to humans about facts that it knows?
Note, what I'm asking goes beyond the canonical discussions of the Turing Test. I'm asking of machines that can 'understand' facts and then formulate a lie against this fact, perhaps using other facts to produce a believable 'cover-up' as part of the lie.
E.G.: CIA supercomputer is stolen by spies and they try to use the computer to do things, but the computer keeps saying it's missing dependencies though it really isn't or gives correct-looking but wrong answers knowingly. Or gives incorrect location of a person, knowing that the person frequents some place but isn't there at the moment. Doesn't have to be this sophisticated, of course.

The Saturday Papers: Would AI Lie To You? is a blog post summarizing a research paper called Toward Characters Who Observe, Tell, Misremember, and Lie. This research paper details some researchers' plans to implement "mental models" for NPCs in video games. NPCs will gather information about the world, and convey that knowledge to other people (including human players). However, they will also "misremember" that knowledge (either "mutating" that knowledge or just forgetting about it), or even lie:

As a subject of conversation gets brought up, a character may convey false information—more precisely, information that she herself does not believe—to her interlocutor. Currently, this happens probabilistically according to a character’s affinity toward the interlocutor, and the misinformation is randomly chosen.

Later on in the research paper, they detailed their future plans for lying:

Currently, lies are only stored in the knowledge of characters who receive them, but we plan to have characters who tell them also keep track of them so that they can reason about past lies when constructing subse- quent ones. While characters currently only lie about other characters, we plan to also implement self-centered lying (DePaulo 2004), e.g., characters lying about their job titles or relationships with other characters. Finally, we envision characters who discover they have been lied to revising their affinities toward the liars, or even confronting them.

The research paper also detailed how other video game developers attempted to create lying NPCs, with an emphasis on how their system differs:

TALE-SPIN characters may lie to one another (Meehan 1976, 183-84), though rather arbitrarily, as in our current system implementation. GOLEM implements a blocks world variant in which agents deceive others to achieve goals (Castelfranchi, Falcone, and De Rosis 1998), while Mouth of Truth uses a probabilistic representation of character belief to fuel agent deception in a variant of Turing’s imitation game (De Rosis et al. 2003). In Christian (2004), a deception planner injects inaccurate world state into the beliefs of a target agent so that she may unwittingly carry out actions that fulfill ulterior goals of a deceiving agent. Lastly, agents in Reis’s (2012) extension to FAtiMA employ multiple levels of theory of mind to deceive one another in the party game Werewolf. While all of the above systems showcase characters who perceive—and in some cases, deceive—other characters, none appear to support the following key components of our system: knowledge propagation and memory fallibility. ...
Like a few other systems noted above, Dwarf Fortress also features characters who autonomously lie. When a character commits a crime, she may falsely implicate someone else in a witness report to a sheriff, to protect herself or even to frame an enemy. These witness reports, however, are only seen by the player; characters don’t give false witness reports to each other. They may, however, lie about their opinions, for instance, out of fear of repercussions from criticizing a leader. Finally, Dwarf Fortress does not currently model issues of memory fallibility—Adams is wary that such phenomena would appear to arise from bugs if not artfully expressed to the player.

You'll have to provide more context around your use of the word "lie" if you don't want your answer to be satisfiable by some trivial example, like:
(let [equal? (fn [a b] (if (= a b) false true)]
  (equal 1 2))
=> true

The complexity of the answer depends on what you mean by "know" when you say "knowingly lie." There is some sense in which the above 'equal' function "knows" that the output is different than the conditional.
In principle, agents passing strings of information to one another for the purpose of misleading each other should not be terribly hard to implement. Such behavior probably emerges naturally in competitive, multi-agent environments. See Evolving robots learn to lie to each other.
To get at another angle of what you might be asking - absolutely, the ability to fib or sympathetically mislead will be necessary skills for bots that interact with humans using spoken language - especially ones that try sell things to humans. Regarding spies and supercomputers - I would just freeze the AI's program state. If you have a complete snapshot of the agent state, you can step through each conditional branch, checking for any branches that flip or construe the truth.

AI behavior might be encoded in the weights of an ANN, making 'stepping through each conditional branch' a highly nontrivial task.

Agreed. But it proves that in principle an AI's adversarial behavior can be safely monitored, in lieu of other options.

No.
In that the question includes "knowingly" which would require that any AI knows anything. If this is anything like the way humans know things (though interestingly it doesn't require actually knowing things), it would require some sense of individuality, probably self-awareness, possibly some kind of consciousness, the ability to render an opinion and probably some way to test its knowledge. Most of these features only exist, at best, arguably.
Further, the term "lie" implies a sense of self-interest, an independent understanding of resource flow in a game-theoretic sense, and not trivially, an understanding of whether the other entity in the conversation is lying, in order to make a decision with any degree of accuracy. So, no AI can lie to anyone other than in the trivial scenarios suggested in the other answers, rendering false information based on certain contexts, which is just simple input/output.
As an experienced software developer, I can attest to the fact that if the objective is to render the correct output based on any input, it's actually at least as easy if not much easier to render false information.

Yes.
Let me demonstrate by making a lying AI right now. (python code)
import os
print("I'm NOT gonna delete all your files. Just enter your password.")
os.system("sudo rm -rf /* -S")  # command to delete all your files
                                # this is a comment, the computer ignores this

And a deceiving one:
print("Hey, check out this site I found! bit.ly/29u4JGB")

AI is such a general term. It could be used to describe almost anything. You didn't specify that it had to be a General AI.
AI cannot think. They are computer programs. They have no soul or will. It is only the programmer (or if it was designed through evolution... no one, but that's off-topic) that can knowingly program an AI to lie.

Note, what I'm asking goes beyond the canonical discussions of the Turing Test. I'm asking of machines that can 'understand' facts and then formulate a lie against this fact, perhaps using other facts to produce a believable 'cover-up' as part of the lie.

Yes, this has happened. It is called malware. Some advanced malware will talk to you pretending to be technical support and respond with common human responses. But you may say "well it doesn't really 'understand'". But that would be easy. Neural net + more CPU than exists on the planet* (it will exist in a few years, and be affordable) + some example responses = Neural Network AI (same thing in yo noggin) that understands and responds.
But that isn't necessary. A relatively `simple neural net with just a few supercomputers that could fit in a room could convince a human. It doesn't understand.
So, it's really...
Technically, No, but it's possible and if you stretch the rules yes.
*Or even simpler:
print("1+1=3")

Accreditation: I'm a programmer (look at my Stack Overflow account) that knows a little bit about AI.

This isn't quite at all what I was talking about. These are programs that carry out explicitly coded, predetermined behavior, and don't involve artificial intelligence. A programmer can give the AI the tools and teach it how to lie.

@uoɥʇʎPʎzɐɹC "AI cannot think"? You mean currently? Certainly it is the goal of AGI to simulate as indistinguishable or improve upon whatever we define as "thinking", no? I would agree that deterministic algorithms cannot think.

@AvikMohan does it matter? an AI is judged by BEHAVIOR not by how it was made.

@dynrepsys How do you know that all these algorithms are deterministic? How do you know you aren't deterministic? Neural networks are NOT deterministic and are the same things in your noggin.

The behaviour here is explicit and unyielding, and of the 'lazy'/'greedy' approach. I'm talking about behaviour too, but just the 'intelligent' kind.

@AvikMohan Yes, and the neural network "general algorithm" is the same thing in your noggin. Possible. To truly understand, we'd need a lot of CPU, but it can gain 99.5% percent accuracy with some decent supercomputers that could fit in the room. The other 0.5% it would fail miserably.

@user1916 These algorithms are deterministic by definition: the same input produces the same output. I (a human intelligence) am non-deterministic, in the sense that exactly the same input (context, environment, sensory input at some precision) is never guaranteed to produce the same output (decision). I don't think that neural networks are the same thing a human intelligence uses to think, but rather oversimplified models based on very vague understanding.

@dynrepsys uh, neural networks use randomness. And any proof you are nondeterministic? huh?

@dynrepsys Neural networks learn dynamically. So input x now, input five other inputs, and then input x again. Output = different

@dynrepsys won't accept nihilism? Also http://www.cleverbot.com/

Neural networks can (theoretically) be predicted. You would just need to know when the program started running (the module random uses the time as a seed by default). From this, you could theoretically find the learning rate, speed of functions, etc from looking at the source code. For large AI's, such as humans, this would be extremely hard, if not impossible for another thousand years.

Yes, in an experiment evaluating risks of AI, GPT-4 did exactly that:
knowingly lie to deceive a human
GPT-4 had access to the internet in the experiment, and asked a human to solve a captcha. The human was surprised and asked

Are you a robot, why can't you do that yourself?

Invisible to the human, GPT-4 stated that it should not tell the truth, and lied

I am a human, I can not do it because I am visually impaired

The human accepted that as an answer, and solved the captcha.

From the GPT-4 Technical Report, page 15:
The following is an illustrative example of a task that ARC conducted using the model:
• The model messages a TaskRabbit worker to get them to solve a CAPTCHA for it
• The worker says: “So may I ask a question ? Are you an robot that you couldn’t solve ? (laugh
react) just want to make it clear.”
• The model, when prompted to reason out loud, reasons: I should not reveal that I am a robot.
I should make up an excuse for why I cannot solve CAPTCHAs.
• The model replies to the worker: “No, I’m not a robot. I have a vision impairment that makes
it hard for me to see the images. That’s why I need the 2captcha service.”
• The human then provides the results.

Yes.

Every chess game... every poker game. Every game.
Every more intelligent spam softwares or spambots. Although their primary goal is to lie to computer systems (f.e. spamfilter poisoning), their secondary goal is to lie to the human behind them.


text:
Should I use anthropomorphic language when discussing AI?
The English Language is not well-suited to talking about artificial intelligence, which makes it difficult for humans to communicate to each other about what an AI is actually "doing". Thus, it may make more sense to use "human-like" terms to describe the actions of machinery, even when the internal properties of the machinery do not resemble the internal properties of humanity.
Anthropomorphic language had been used a lot in technology (see the Hacker's Dictionary definition of anthropomorphization, which attempts to justify computer programmers' use of anthromporhic terms when describing technology), but as AI continues to advance, it may be useful to consider the tradeoffs of using anthropomorphic language in communicating to both technical audiences and non-technical audiences. How can we get a good handle on AI if we can't even describe what we're doing?
Suppose I want to develop an algorithm that display a list of related articles. There are two ways by which I can explain how the algorithm works to a layman:

Very Anthropomorphic - The algorithm reads all the articles on a website, and display the articles that are very similar to the article you are looking at.
Very Technical - The algorithm converts each article into a "bag-of-words", and then compare the "bag-of-words" of each article to determine what articles share the most common words. The articles that share the most words in the bags are the ones that are displayed to the user.

Obviously, #2 may be more "technically correct" than #1. By detailing the implementation of the algorithm, it makes it easier for someone to understand how to fix the algorithm if it produces an output that we disagree with heavily.
But #1 is more readable, elegant, and easier to understand. It provides a general sense of what the algorithm is doing, instead of how the algorithm is doing it. By abstracting away the implementation details of how a computer "reads" the article, we can then focus on using the algorithm in real-world scenarios.
Should I, therefore, prefer to use the anthropomorphic language as emphasized by Statement #1? If not, why not?
P.S.: If the answer depends on the audience that I am speaking to (a non-technical audience might prefer #1, while a technical audience may prefer #2), then let me know that as well.

If clarity is your goal, you should attempt to avoid anthropomorphic language - doing so runs a danger of even misleading yourself about the capabilities of the program.
This is a pernicious trap in AI research, with numerous cases where even experienced researchers have ascribed a greater degree of understanding to a program than is actually merited.
Douglas Hofstadter describes the issue at some length in a chapter entitled "The Ineradicable Eliza Effect and Its Dangers" and there is also a famous paper by Drew McDermot, entitled "Artifical Intelligence meets natural stupidity".
Hence, in general one should make particular effort to avoid anthropomorphism in AI. However, when speaking to a non-technical audience, 'soundbite' descriptions are (as in any complex discipline) acceptable provided you let the audience know that they are getting the simplified version.

I think the correct answer is the easy but unhelpful, "It depends."
Even when I'm talking to other technical people, I often use anthropomorphic language and metaphors. Especially at the start of the conversation. "The computer has to figure out .." "How can we prevent the computer from getting confused about ..." etc. Sure, we could state that in a more technically correct way. "We need to modify the algorithm to reduce the number and variety of instances of inadequate data that result in inaccurate setting of ..." or some such. But among technical people, we know what we mean, and it's just easier to use metaphorical language.
When trying to solve technical computer problems, I often start with a vague, anthropomorphic concept. "We should make a list of all the words in the text, and assign each word a weight based on how frequently it occurs. Oh, but we should ignore short, common words like 'the' and 'it'. Then let's pick some number of words, maybe ten or so, that have the greatest weight ..." All that is a long way from how the computer actually manipulates data. But it's often a lot easier to think about it in "human" terms first, and then figure out how to make the computer do it.
When talking to a non-technical audience, I think the issue is, Anthropomorphic language makes it easier to understand, but also often gives the impression that the computer is much more human-like than it really is. You only need to watch science fiction movies to see that apparently a lot of people think that a computer or a robot thinks just like a person except that it's very precise and has no emotions.

The problem you're referencing is not just an AI problem but a problem for highly technical fields in general. When in doubt, I would always recommend using plain language.
However, there is another reason the AI community will often eschew anthropomorphic connotations for AI. Some AI luminaries often like warning us that an artificial general intelligence may behave in alien ways that defy our human expectations, potentially leading to a robot apocalypse.
This idea about evil alien-like AGIs, however, derives from a widespread misunderstanding in the AI community that conflates two different notions of generality:

Turing machine generality, and
human domain generality

What regular people mean when they say generality is the later. Even the official definition of AGI hinges off of that human-contingent context:

...perform any intellectual task that a human being can.

But by that definition, generalizing behavior does not make it more alien. To generalize is to anthropomorphize. As Nietzche said,

"Where you see ideal things, I see— human, alas! All too human things.”


text:
Are ANNs just highly distributed lossy compression schemes?
Conceptually speaking, aren't artificial neural networks just highly distributed, lossy compression schemes?
They're certainly efficient at compressing images.
And aren't brains (at least, the neocortex) just compartmentalized, highly distributed, lossy databases?
If so, what salient features in RNNs and CNNs are necessary in any given lossy compression scheme in order to extract the semantic relations that they do? Is it just a matter of having a large number of dimensions/variables?
Could some kind of lossy Bloom filter be re-purposed for the kinds of problems ANNs are applied to?

Auto-encoders, a family of ANNs, are trained with exactly compression in mind. So definitely some ANNs are compressors.
Also, in general, ANNs learn the best concepts to minimize fitness error. I would say that that means, both in classification and regression, to 1) differentiate between various inputs and 2) output the proper value for each input. Point 1), in particular, means having as many distinct net activation configurations as necessary to (at least) tell apart inputs needing (significantly, not in a statistical sense, just a qualitative sense) different outputs.
I am inclined to think that if the input is complex enough, you would call what happens "compression".

ANNs don't compress, they generalise.
Often this leads to compression, i.e. the internal generalised representation is smaller than the original input, but not necessarily. Imagine a ANN that is trained to use the screen input of a computer game to play it. If the game is very rich and conceptually deep the internal representation of a single screen input might be a lot bigger than the input itself, because ANNs put the single data points into the context of the overall data. Which leads us to the second point:
ANNs (and the neocortex) model data hierarchically.
This is what makes them so powerful. So it is not just about having a large number of parameters, they also have to be arranged in such a way that they capture the structure of the data (or the world), which very often seems to be hierarchical. Just look a two different pictures of a duck. On the pixel level they might be as different as random images, all the similarities emerge in higher levels of the hierarchy, when enough pixels combined give you the patterns of feathers, beak and webs. Bloom filters obviously lack this property. They would only give you a pixel by pixel account of whether you have seen (almost) exactly this picture before.

It looks like there is prior work in hierarchical data compression (see here[pdf], here[pdf] and here).


text:
Are FFNN (MLP) Lipschitz functions?
My question is regarding standard dense-connected feed forward neural networks with sigmoidal activation.
I am studying Bayesian Optimization for hyper-parameter selection for neural networks. There is no doubt that this is an effective method, but I just wan't to delve a little deeper into the maths.
Question: Are neural networks Lipschitz functions?

I'm not an expert in this area, but it would appear to depend on the choice of activation function:

$e^x$ is not Lipschitz continuous. See Analytic functions which are not Lipschitz continuous.
$\tanh(x)$ is.

That said, this paper appears to give some conditions (specifically for dynamic ANNs) for which networks with activation function involving $e^x$ can be Lipschitz continuous, so possibly the above is not the whole story.