God, no. I just scraped the thumbnails from https://www.pornhub.com/pornstars?gender=m2f and the top photos there.Why are you asking me, you're the one who watched all this porn
Do they really never take a close-up of the face?
It's Pride month AND Black Usual Thangs Month at once, we can say it openly and proudly - dem niggas gay.
Get some Amazon MTurk workers to do it for a few pennies. They'll appreciate the diversion.
To be fair the girls.zip is nearly triple the download, so most guys are likely going for the quickets download that takes up the least amount of space.
I probably worded it badly, but I think you misunderstand. It's not so much about whether your library handles it - if it didn't, it would be pretty poor. If you are experiencing issues with class imbalance and inaccuracy, this might help you especially.
But that part is practically already being done for him, using that library. Most machine learning networks use very low resolution representations, such as 256x256 for AlexNet. We are not at the point where we can use a very high resolution version and the number of features we would have to learn would explode computation time.It seems to me that you should try an easier version of the problem first rather than going right to identifying 40-pixel-wide faces from porn stills. Why not use a dataset of higher-res images cropped to just the face looking directly at the camera? Get a proof of concept done first before moving on to the harder tasks.
The test images provided with the library you're using are much higher-res than yours, they may not even have tested it on low-res images.
EDIT: and if you do get something working, then you can progressively lower the input images' resolution and see how strong "beer goggles" you have to apply to your algorithm to fool it
I already use FaceNet (https://arxiv.org/pdf/1503.03832.pdf) to get the embedding of the face, and that should be very resistant to such changes.I probably worded it badly, but I think you misunderstand. It's not so much about whether your library handles it - if it didn't, it would be pretty poor. If you are experiencing issues with class imbalance and inaccuracy, this might help you especially.
For example, if you had an image of the same person in different lighting conditions, with different croppings, you would expect it to be categorized the same way. That way, the machine learning algorithm has an easier time honing in on which features you want it to pay attention to. What you are practically doing is showing the algorithm different examples of images, but it does not know which aspects of the image it is supposed to care about, and it figures that out by itself. But just as the example of the images of ducks and cats being categorized on irrelevant features, using data augmentation might help you help the algorithm out on telling it what to pay attention to. If you have a dark and a light image of a woman, and they are both classified as women, the algorithm learns that it is not the lighting that is decisive. For a similar reason dropout layers are advantageous because a machine learning algorithm will likely use the easiest to detect features to classify your image and having random dropouts will take away some of these features from time to time.
Hinton, Geoffrey E., Nitish Srivastava, Alex Krizhevsky, Ilya Sutskever, and Ruslan R. Salakhutdinov. "Improving neural networks by preventing co-adaptation of feature detectors." arXiv preprint arXiv:1207.0580 (2012).
Why should you care about data augmentation?
I think there is some more fundamental issue here. Is there any reason why the false negative rate would be so extremely high? It's doesn't seem to be a class imbalance thing, since the tranny pics get more weight.
Ouch, yeah I just thought about that, right after I hit reply. I'm sorry for the confusion. If you are getting exactly the same feature vectures out after image augmentation, which should be the case with a decent facial recognition library, then that's redundant nonsense, of course. If the cosine-distance, or whatever other metric they use, is practically zero between any two (augmented) images of the same person, then this is of no use.
Well, yes. There is a reason, of course. The simplest reason might be that the data simply do not deliver what you are looking for. For example, if there is not sufficient system and the markers are too random, it won't be able to classify it correctly, just as if you tried to classify the brand of a car based on the paint job alone.
Do you mean small in terms of the number of features? That should be fine, even if it's very pre-filtered data. There might be very few features, but if the facial features it does give you can be used in any way to classify the images, that should be enough nonetheless.
I think that is already done at this point, by Seeta. That library is, in his current approach, responsible for the embeddings he is using. That is already done at the point of the code he is showing, because he appears to be loading the embeddings and classifcations from an .npy file (AKA "numpy dumps" or whatever you like to call them). He is loading two of them at the begining of the code he posted.
If he already has the embeddings then that is not needed anymore, IMHO. Those already represent the face. That seems to be the 128 element feature vector (or however large it happens to be) that comes out of the library.
Sigmoid at its end? I'm not sure what you mean. Sigmoids are usually used as activation functions. Maybe that's a neural network architecture I am not familiar with. The function you have at the end is usualy a softmax/cross entropy for classification.
The problem is that you are assuming that the vector will corrospond to "tranny" features, which isn't necessarily the case. You can check if those features are good by just creating a very small network that gets the features as an input (pre-process the images through the first network and save their output to save time) and returns a classification.
Sigmoid gives you a 0 to 1 range value. In classification terms >0.5 is true and <0.5 is false. Because you have only a single output node instead of 2 for softmax it gives the network a far easier time since it needs to backpropogate a single value rather than do a balancing act for two.
If you use the embedding there is no point in data augmentation since you can be sure the original framework was already trained on far more lighting examples. If you use the method of making a new small network for faces then you should augment and see if it makes a difference.
There is no problem in putting them in regardless on either of the networks I proposed since they at worst make the convergence faster without improvement in accuracy.
Facial feminization surgeons often have fair-quality face-on "after" pictures (example).
That is a good question, the central question even, probably. I think it will correspond to or contain such features because if the features can be reliably used to identify a person, in various pictures, then it should also be good enough to identify transgender facial features. In the conception of what it means to be transgender that you would like to teach to the machin learning algorithm, a person cannot look transgender and not transgender at the same time. Then, I think, it would also not be able to match the person reliably, and the reliably of the method they use appears very high.
Yes, typically, although that's not always the case. You also have layer and node weights after that. You can normalize those, of course, but then you are practically just doing what a softmax function would have done, i.e. scale the values in such a manner that they add to one, as in a probability distribution. Either way, if we mean the same thing, and we are on the same page here, I do not really care how he gets that distribution. Which activation function he uses is probably a minor detail at this point.
Right. I think we are on the same page now. That is what I meant. The facial features, i.e. the embeddings that are currently loaded from the numpy files (.npy), should already be robust against that. Do some basic smoke tests that they really are, and that should be fine.
No, probably not. I just thought it would add too much complexity and additional variables.
Excuse me, sir, but this is for SCIENCE!
you may be able to cross reference known trannies with their Instagram posts. This is the next generation of thot patrolling. Patrolling dudes.
Quantity > quality. If you have a big database of pictures like that, it could be used however.
If it's just inaccuracy, the confusion matrix should look something like this:
[[0.5, 0.5],
[0.5, 0.5]]import numpy as np
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from sklearn.decomposition import PCA
from sklearn.utils import shuffle
X = np.load('embeddings.npy')
ls = np.load('label_strings.npy')
y = []
for el in ls:
y.append(0 if el == 'girls' else 1)
y = np.array(y)
X, y = shuffle(X, y)
y_bool = np.where(y, 1, 0)
# Indicies of each class' observations
i_class0 = np.where(y_bool == 0)[0]
i_class1 = np.where(y_bool == 1)[0]
# Number of observations in each class
n_class0 = len(i_class0)
n_class1 = len(i_class1)
# For every observation of class 0, randomly sample from class 1 without replacement
i_class0_downsampled = np.random.choice(i_class0, size=n_class1, replace=False)
# Join together class 0's target vector with the downsampled class 1's target vector
y = np.hstack((y[i_class0_downsampled], y[i_class1]))
X = np.vstack((X[i_class0_downsampled], X[i_class1]))
classifiers = [SVC(gamma=2, C=1, class_weight='balanced')]
names = ["RBF SVM"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)
for name, clf in zip(names, classifiers):
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
print(score)
y_pred = clf.predict(X_test)
print(confusion_matrix(y_test, y_pred, normalize='true'))0.75625
[[0.76219512 0.23780488]
[0.25 0.75 ]]Not using Seeta anymore, only FaceNet and the included MTCNN face detector.
I'll just downsample instead. Does this hurt accuracy, since I'm throwing away data?I would play with the hyperparameters of the classification algorithm you are using a bit (SVM). Sorry, but even after all this time I still cannot give you anything better than a rule of thumb how to choose some of those hyperparameters. I think that is still a common criticism in most fields of machine learning. I see that you are already defining a Python list and are naming the various configurations for the classifiers, which is a thing I like doing as well. Try a few different classifiers and twiddle with their settings a bit, then see what accuracy you can get. Sorry for this trial and error approach.
The default appears to be an RBMF kernel. The scikit documentation suggest grid search, which, to me, sorry to be cynical somehwhat, is little more than fancy trial and error.
https://scikit-learn.org/stable/tutorial/basic/tutorial.html
If everything else, i.e. the facial identification/recognition library, is basically working, you are really only left with tweaking the scikit classifier and its hyperparameters.
But, as always, perhaps I had a brainfart somewhere. I am very smol brain, so if I made an error in logic somewhere, do not feel shy to point it out. I will neg-rate your comment and seethe, but I promise to admit a mistake where I am wrong.
It depends, knowing to differenciate faces might focus on traits in faces that aren't useful to find gender but rather identity.
It is still far better in practice.
Of course for cases with more than one class then a softmax is a must. Plus, you should experiment in different cases of transfer learning if you have the gpu to train more layers than just the new ones.
You should definitely use a MLP rather than an SVM. The feature vectors are very likely to be too problematic to directly partition.
I did some more scraping, and now I have 7000+ trannies and 2000+ girls. How many do I need?
If you are using Facenet then it probably has a way to consider multiple faces in an image. Just pick the face with the highest likelihood. Regardless, unless the data is massively tainted then a classifier should still work despite some false positives. Ditto for Asians, unless they are 90% of the dataset, the network will find how to deal with them. If you have labels for ethinicity, it might help to add an additional race class output to the network that can boost performence.
Highest likelihood of what? They're both faces, but the images are labeled by class. If there's an image marked "trap" and it contains one trap and one man, then it's 50/50 which one gets marked trap and which one discarded.
I am using sklearn's MLPClassifier, inputs are FaceNet's outputs. The accuracy is slightly better than SVM. Adding noise to the images won't change anything.