小编sop*_*ros的帖子

我正在编写一个具有以下形式约束的 pyomo 整数程序：

def example_rule(model, j, t):
    value = sum(model.x[j,i]*(util[i][t]) for i in model.F)
    return 0 <= value <= 1
model.onelateral = Constraint(model.L, model.T, rule=example_rule)

util[i][t]是一个包含始终为 0 或 1 的值的字典。 model.x[j,i]是二元决策变量。

有时当我运行我的模型时，它工作正常。但是，有时当我更改其中的尺寸/值时util[i][t]会引发此错误：

ERROR: Constructing component 'example' from data=None failed:
    ValueError: Invalid constraint expression. The constraint expression resolved to a trivial Boolean (True) instead of a Pyomo object. Please modify your rule to return Constraint.Feasible instead of True.

Error thrown for Constraint 'example[L01]'

我找不到任何一致性为什么它决定它不喜欢util[i][t]. 那里永远不会有任何空值。 …

imblearn库是一个用于不平衡分类的库。它允许您使用scikit-learn估计器，同时使用各种方法（从欠采样到过采样到集成）平衡类。

BalancedBaggingClassifier然而，我的问题是，在使用imblearn 或任何其他采样方法后，如何获得估计器的特征重要性？

from collections import Counter
from sklearn.datasets import make_classification
from sklearn.cross_validation import train_test_split
from sklearn.metrics import confusion_matrix
from imblearn.ensemble import BalancedBaggingClassifier 
from sklearn.tree import DecisionTreeClassifier
X, y = make_classification(n_classes=2, class_sep=2,weights=[0.1, 0.9], n_informative=3, n_redundant=1, flip_y=0, n_features=20, n_clusters_per_class=1, n_samples=1000, random_state=10)
print('Original dataset shape {}'.format(Counter(y)))
X_train, X_test, y_train, y_test = train_test_split(X, y,random_state=0)
bbc = BalancedBaggingClassifier(random_state=42,base_estimator=DecisionTreeClassifier(criterion=criteria_,max_features='sqrt',random_state=1),n_estimators=2000)
bbc.fit(X_train,y_train) 

以下在 Cloudera CDSW 集群网关上成功运行。

import pyspark
from pyspark.sql import SparkSession
spark = (SparkSession
            .builder
            .config("spark.jars.packages","JohnSnowLabs:spark-nlp:1.2.3")
            .getOrCreate()
         )

产生这个输出。

Ivy Default Cache set to: /home/cdsw/.ivy2/cache
The jars for the packages stored in: /home/cdsw/.ivy2/jars
:: loading settings :: url = jar:file:/opt/cloudera/parcels/SPARK2-2.2.0.cloudera1-1.cdh5.12.0.p0.142354/lib/spark2/jars/ivy-2.4.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
JohnSnowLabs#spark-nlp added as a dependency
:: resolving dependencies :: org.apache.spark#spark-submit-parent;1.0
    confs: [default]
    found JohnSnowLabs#spark-nlp;1.2.3 in spark-packages
    found com.typesafe#config;1.3.0 in central
    found org.fusesource.leveldbjni#leveldbjni-all;1.8 in central
downloading http://dl.bintray.com/spark-packages/maven/JohnSnowLabs/spark-nlp/1.2.3/spark-nlp-1.2.3.jar ...
    [SUCCESSFUL ] JohnSnowLabs#spark-nlp;1.2.3!spark-nlp.jar (3357ms)
downloading https://repo1.maven.org/maven2/com/typesafe/config/1.3.0/config-1.3.0.jar ...
    [SUCCESSFUL ] com.typesafe#config;1.3.0!config.jar(bundle) (348ms)
downloading https://repo1.maven.org/maven2/org/fusesource/leveldbjni/leveldbjni-all/1.8/leveldbjni-all-1.8.jar ... …

我想比较 Kolmogorov-Smirnov (KS) 和 Anderson-Darling (AD) 测试的样本对。我分别用scipy.stats.ks_2samp和实现了这个scipy.stats.anderson_ksamp。我希望类似样本的统计数据较低（相同样本为 0），而更多不同样本的统计数据较高。

在相同样本和非常不同的样本（没有重叠）的情况下，ks_2samp提供预期的结果，同时anderson_ksamp为相同的样本提供负值，更重要的是，对于非常不同的样本抛出错误（可能是由于样本大小：200在下面的例子中）。

以下是说明这些发现的代码：

import scipy.stats as stats
import numpy as np
normal1 = np.random.normal(loc=0.0, scale=1.0, size=200)
normal2 = np.random.normal(loc=100, scale=1.0, size=200)

在相同样本上使用 KS 和 AD：

sstats.ks_2samp(normal1, normal1)
sstats.anderson_ksamp([normal1, normal1])

分别返回：

# Expected
Ks_2sampResult(statistic=0.0, pvalue=1.0) 
# Not expected
Anderson_ksampResult(statistic=-1.3196852620954158, critical_values=array([ 0.325,  1.226,  1.961,  2.718,  3.752]), significance_level=1.4357209285296726)

在不同的样本上：

sstats.ks_2samp(normal1, normal2)
sstats.anderson_ksamp([normal1, normal2])

分别返回：

# Expected
Ks_2sampResult(statistic=1.0, pvalue=1.4175052453413253e-89)
# Not expected
---------------------------------------------------------------------------
OverflowError                             Traceback (most recent call last) …

我尝试运行以下代码：

from imblearn import under_sampling, over_sampling
from imblearn.over_sampling import SMOTE

sm = SMOTE(random_state=12, ratio = 1.0)
x_SMOTE, y_SMOTE = sm.fit_sample(X, y) 

这给我错误信息：

ModuleNotFoundError: No module named 'imblearn'

我尝试以多种方式安装imblearn模块，它们似乎都可以工作（安装过程中未出现任何错误，但是当我运行上述代码时，出现错误消息）。

我使用其他stackoverflow问题中建议的以下内容尝试了taltaling imblearn：

pip install -U imbalanced-learn
pip install imblearn
!pip install imblearn
pip install -c glemaitre imbalanced-learn
pip install imblearn==0.0

这些似乎都无济于事...有什么想法吗？谢谢！

我在 Ubuntu 中使用 1.9.2 的 Airflow 版本和 Python 2.7。我试图从ParentOperator本身工作正常的类继承并创建一个名为ChildOperator. 但是当我创建一个ChildOperator实例时，我认为这里缺少一些关键字参数或弄乱了，我收到了这个错误：

airflow.exceptions.AirflowException：初始化运算符时使用关键字参数

这是一个简化的示例：

class ParentOperator(BaseOperator, SkipMixin):

    @apply_defaults
    def __init__(self,
             conn_id,
             object,
             args={},
             s3_conn_id=None,
             s3_key=None,
             s3_bucket=None,
             fields=None,
             *args,
             **kwargs
             ):

        super(ParentOperator, self).__init__(*args, **kwargs)
        ...


class ChildOperator(ParentOperator):

    @apply_defaults
    def __init__(self,
             conn_id,
             object,
             args={},
             s3_conn_id=None,
             s3_key=None,
             s3_bucket=None,
             fields=None,
             *args,
             **kwargs
             ):

        args=...
        super(ChildOperator, self).__init__(
            conn_id,
            object,
            args=args,
            s3_conn_id=s3_conn_id,
            s3_key=s3_key,
            s3_bucket=s3_bucket,
            fields=fields,
            *args,
            **kwargs
        )

...

myobjc = ChildOperator(
    conn_id="my_default",
    object=table,
    args={},
    s3_conn_id='s3_postgres_dump',
    s3_key=s3_key,
    s3_bucket=s3_bucket,
    dag=dag,
    task_id="task1"
)

知道是什么导致了这个错误？这更像是 …

我正在使用 Tensorflow 和 Flask 开发一个 python(3.6) 项目。我需要在烧瓶函数中运行 Tensorflow 模型，但它返回错误。

这是我的代码：

应用程序

app = Flask(__name__)


@app.route('/<path:image_url>')
def grab_image(image_url):
    url = str(image_url)
    r = requests.get(url, allow_redirects=True)
    print('Url is as: {}'.format(url))
    filename = url.split('/')[-1]
    open(filename, 'wb').write(r.content)
    img = Image.open(filename)
    # img.show()
    img.save('/Users/abdul/PycharmProjects/ImgSeg/uploads/photo.jpg', 'JPEG')

    # create_new_images('/Users/abdul/PycharmProjects/ImgSeg/uploads/photo.jpg')

    class DeepLabModel(object):
        """Class to load deeplab model and run inference."""

        INPUT_TENSOR_NAME = 'ImageTensor:0'
        OUTPUT_TENSOR_NAME = 'SemanticPredictions:0'
        INPUT_SIZE = 513
        FROZEN_GRAPH_NAME = 'frozen_inference_graph'

        def __init__(self, tarball_path):
            """Creates and loads pretrained deeplab model."""
            self.graph = tf.Graph()

            graph_def = None
            # …

我想知道是否有一种首选的或至少更具可读性/漂亮/pythonic 的方式来根据放入其中的数据使句子复数。

这就是我现在的做法

ret = f'Done! {deleted} entr{"y was" if deleted == 1 else "ies were"} removed.'

我知道这行得通，但是当我去阅读它时，它就是不舒服。我想过创建一个函数或使用 dict-switch（这是我有点喜欢的东西），但也许有人知道更好的方法。

我尝试过的解决方案：

使用字典

plural = {1:'y was'}
ret = f'Done! {deleted} entr{plural.get(deleted, "ies were")} removed.'

使用函数

def plural(num: int):
    return 'y was' if num == 1 else 'ies were'

使用布尔运算符

ret = f'Done! {deleted} entr{deleted != 1 and "ies were" or "y was"} removed.'

这些确实是我现在能想到的唯一有意义的其他方式，也是我想要这样做的原因是因为我有多个地方需要将单词设为复数。问题是，我可能想在某些地方使用不同的措辞，并希望避免重复自己将单词设为复数以供人类阅读的格式。

我有一个带有整数约束的 LP，我想使用 Python 以精确算术求解它。其实我只需要一个可行点。

编辑：“精确算术”这里指的是无界枚举数和分母的有理数。

之前的尝试：

• 查找线性程序的精确解决方案提到了 qsoptex，但是当我尝试导入它时，我得到了ImportError: libqsopt_ex.so.2: cannot open shared object file: No such file or directory，尽管据我所知，我给出了该库的路径。
• SoPlex 可在控制台上运行，但我找不到 Python 界面。
• PySCIPOpt ( https://github.com/SCIP-Interfaces/PySCIPOpt ) 是 SCIP 的 Python 接口，包括 SoPlex，但我不知道如何调用特定的求解器（具有特定的选项）。
• cdd（https://pycddlib.readthedocs.io/en/latest/linprog.html）做了一些事情，称之为 LP，但我不知道他们实际解决的是哪个问题。

速度只是一个中等问题。我的较大实例有大约 500 个带有框约束的变量和 40 个等式，但涉及的数量可能很大。

Pandascorr()函数将其使用限制为成对计算。但是，如何使用薪水作为下面数据框中的因变量来计算数据框中三个变量的相关性？

    GPA    IQ    SALARY
0   3.2    100   45000
1   4.0    140  150000
2   2.9    90    30000
3   2.5    85    25000
4   3.6    120   75000
5   3.4    110   60000
6   3.0    05    38000