More elegant way to count anagrams in Python?
Performance (Language independent)

The permutations scale factorially with the word length and your loop code squares quadratically with the number of words. 
Both are really bad scaling factors.
The nice thing to realize, that all equivalent anagrams map to the same multiset.
There are python libraries for multisets, but already with the built-in tools you can go a long way.
Two strings are equivalent, under "Anagram-relation", if they are the same after sorting. We will treat the sorted string as representation of our Anagram equivalence class. Since strings are immutable you can even use these represantions directly as dictionary keys.

Your code becomes then quite short

from collections import defaultdict

def count_anagrams(words):
    result = defaultdict(list)
    for word in words:
        result[''.join(sorted(word))].append(word)
    return dict(result)


This scales linearly with word number and (n * log(n)) with word length. (Under the assumption that dictionary insertion is O(1) and sorted uses a reasonable sorting algorithm.).

The output of

count_anagrams(['stop', 'test', 'post'])


is then 

{'opst': ['stop', 'post'], 'estt': ['test']}


You can change it to your needs by transforming it to your desired output with len etc.

If you want to convert it to the exact same form as you have it, one example function would be:

def convert_output(words_in_anagram_class):
    return {word: len(words)
            for words in words_in_anagram_class.values() 
            for word in words}


Then you can call convert_output(count_anagrams(words)). If you want to, you can combine these two functions into one.
(Although this is IMHO a far less useful representation of your data.)

Small stuff (Python nitpicks)

map can and should be replaced with comprehensions. Especially if you cast the result into a list.
[f(x) for x in iterable] is far nicer to read than list(map(f, iterable)).
If you really want a generator, there are also generator expressions
(f(x) for x in iterable).