A way to maintain classifier's recall while improving precision I built a ML classifier, it achieved quite good recall (0.8) but the precision is low (0.3). Is there any way to maintain such recall while improving precision?
 A: I don't know each library you are using. But most ML libraries have model optimizers built in to help you with this task.
For instance, if you using sklearn, you can use RandomizedSearchCV to look for a good combination of hyperparameters for you. For instance, if you training a Random Forest classifier":
#model
MOD = RandomForestClassifier() 
#Implemente RandomSearchCV
m_params = { 
            "RF": {
                    "n_estimators" : np.linspace(2, 500, 500, dtype = "int"),  
                    "max_depth": [5, 20, 30, None], 
                    "min_samples_split": np.linspace(2, 50, 50, dtype = "int"),  
                    "max_features": ["sqrt", "log2",10, 20, None],
                    "oob_score": [True],
                    "bootstrap": [True]
                    },
            }
    scoreFunction = {"recall": "recall", "precision": "precision"}
    random_search = RandomizedSearchCV(MOD,
                                       param_distributions = m_params[model], 
                                       n_iter = 20,
                                       scoring = scoreFunction,               
                                       refit = "recall",
                                       return_train_score = True,
                                       random_state = 42,
                                       cv = 5,
                                        verbose = 1 + int(log)) 

    #trains and optimizes the model
    random_search.fit(x_train, y_train)

    #recover the best model
    MOD = random_search.best_estimator_

Note that the parameters scoring and refit will tell the RandomizedSerachCV which metrics you are most interested in maximizing. This method will also save you the time of hand tuning (and potentially overfitting your model on your test data). 
Good luck!
A: (for problems like these, always have the two by two contingency table in mind; see wikipedia's Recall/Precision or Sensitivity/Specificity for details)
Recall (or sensitivity) is the same as P(test/classifier is positive | reality is true) or True Positives/(True Positives + False Negatives) or True positives/True items
Precision (or positive predictive value) is the same as P(reality is true | test/classifier is positive) or True Positives/(True Positives + False Positives) or True positives/Positive items
Better recall means more hits of reality (true things more likely included in positives), better precision means more hits of positives (if you classify positive, more likely to be true).
One can arbitrarily increase recall by making your classifier include more (sort of without caring if they're not true). You can have perfect recall by just saying everything is positive. There'll be no false negatives that way. Of course, you'll have lots of false positives. In the contingency table, it's like moving the horizontal line between positives and negatives down. It obviously increases recall (and may or may not effect precision).
Since everything here is dual we can say:
One can arbitrarily increase precision by increasing the leniency in considering your gold-standard to have more and more true's. You can have perfect precision by just saying everything is true. There'll be no false positives that way. Of course, you'll have lots of false negatives.  It obviously increases precision (and may or may not effect precision). (Yes, this seems like a strange interpretation but bear with me)
But that seems a little arbitrary (for both). 
When you increase one (by changing some cutoff), you will tend to decrease the other. What you're asking for is to avoid the decrease. That's surely better. The vague way to do that is to include things that should be found (turn an FN to an TP) but don't then also include things that shouldn't (don't turn TN into FP).
What do you have control over? The classifier itself? Or the feature space (the data points themselves)? If the classifier, well, that's part of the algorithm design, so I'll assume he feature space itself.
To make an over simplified example, let's consider a search engine. Suppose you want to find web pages that involve a concept X. If you start off with X, you'll be missing webpages that mention synonyms of X. If you add a synonym Y to a search, you turn some False Negatives to True positives (you'll collect more that you were missing before). 
But that new word Y may be ambiguous and its alternate meaning may include more things that you don't want (increasing False Positives, reducing precision). To prevent that, you'll want to exclude contexts where Y has the unintended alternate meaning. 
A: Precision and recall are a tradeoff. Typically to increase precision for a given model implies lowering recall, though this depends on the precision-recall curve of your model, so you may get lucky. 
Generally, if you want higher precision you need to restrict the positive predictions to those with highest certainty in your model, which means predicting fewer positives overall (which, in turn, usually results in lower recall).
If you want to maintain the same level of recall while improving precision, you will need a better classifier.
A: One other alternative which is not stated here is to do oversampling and under-sampling of data points corresponding to different labels in your training dataset. In this way, you ensure that your model has balanced representation of training data. This is called class balanced and can improve recall considerably, which keeping precision fairly manageable. 
