小编Sca*_*Boy的帖子

当我运行 React.js 前端时，我收到此警告：

index.js:1446 Warning: Failed prop type: The prop `children` is marked as required in `InputAdornment`, but its value is `undefined`.
    in InputAdornment (created by WithStyles(InputAdornment))
    in WithStyles(InputAdornment) (at TopControls.js:101)
    in div (created by InputBase)
    in InputBase (created by Context.Consumer)
    in WithFormControlContext(InputBase) (created by WithStyles(WithFormControlContext(InputBase)))
    in WithStyles(WithFormControlContext(InputBase)) (created by Input)
    in Input (created by WithStyles(Input))
    in WithStyles(Input) (created by TextField)
    in div (created by FormControl)
    in FormControl (created by WithStyles(FormControl))
    in WithStyles(FormControl) (created by TextField)
    in TextField (at TopControls.js:91) …

我有两个 React 组件，我希望它们彼此水平对齐。我使用 Material-UI 的 Grid 来对齐组件（但也欢迎其他解决方案）。问题是组件InputVariables和Chart放置在彼此的顶部（作为两行），而不是在单行中水平对齐。我究竟做错了什么？

当前对齐：

| InputVariables | 
| Chart          |
|         Button |

所需对齐：

| InputVariables | Chart |
|                 Button |

主要成分：

import React from 'react';
import PropTypes from 'prop-types';
import withStyles from '@material-ui/core/styles/withStyles';
import CssBaseline from '@material-ui/core/CssBaseline';
import Grid from '@material-ui/core/Grid';
import AppBar from '@material-ui/core/AppBar';
import Toolbar from '@material-ui/core/Toolbar';
import Paper from '@material-ui/core/Paper';
import Button from '@material-ui/core/Button';
import Typography from '@material-ui/core/Typography';
import Card from '@material-ui/core/Card';
import CardActionArea from '@material-ui/core/CardActionArea';
import …

我正在使用带有 Tensorflow 后端的 Keras 开发多类分类问题（4 个类）的模型。的值y_test具有 2D 格式：

0 1 0 0
0 0 1 0
0 0 1 0

这是我用来计算平衡精度的函数：

def my_metric(targ, predict):
    val_predict = predict
    val_targ = tf.math.argmax(targ, axis=1)
    return metrics.balanced_accuracy_score(val_targ, val_predict)

这是模型：

hidden_neurons = 50
timestamps = 20
nb_features = 18

model = Sequential()

model.add(LSTM(
                units=hidden_neurons,
                return_sequences=True, 
                input_shape=(timestamps,nb_features),
                dropout=0.15
                #recurrent_dropout=0.2
              )
         )

model.add(TimeDistributed(Dense(units=round(timestamps/2),activation='sigmoid')))

model.add(Dense(units=hidden_neurons,
               activation='sigmoid'))


model.add(Flatten())

model.add(Dense(units=nb_classes,
               activation='softmax'))

model.compile(loss="categorical_crossentropy",
              metrics = [my_metric],
              optimizer='adadelta')

当我运行此代码时，出现此错误：

-------------------------------------------------- ------------------------- TypeError Traceback (最近调用 last) in () 30 model.compile(loss="categorical_crossentropy", 31 …

我需要将列添加到 DataFrame df。所有新列的值应沿着 的所有行固定df：

df = {
       "NUM":[1,2],
       "WAKE":["M","H"],
       "DISTANCE":[780,500]
     }

new_df = pd.DataFrame(df)

这就是我尝试添加具有固定值的新多列的方法。

for column, row in new_df.iterrows():
    row["TEMPERATURE"] = 20
    row["VISIBILITY"] = 5000
    row["WIND"] = 10

此代码不会失败，但不会创建新列。

预期结果：

NUM   WAKE  DISTANCE  TEMPERATURE  VISIBILITY  WIND
1     M     780       20           5000        10
2     H     500       20           5000        10

有没有办法在Material-UIoptions的下拉菜单中按字母顺序显示？

我知道可以简单地使用 来对数组进行排序arr.sort()。但是，如果我这样做const options = [...].sort()，那么我仍然会在下拉菜单中看到未排序的值。

const options = [
  {label:"B",value:8033.86},
  {label:"A",value:483.93},
  {label:"Z",value:1246.3},
  {label:"C",value:145.0},
  {label:"E",value:244.5}
]

<Grid item xs={true}>
  <FormControl
      className={this.props.styles.formControl}
      margin="normal">
      <InputLabel shrink htmlFor="distanceTarget-label-placeholder">
          Target:
      </InputLabel>
      <Select
        onChange={(event) => this.props.handleChange("distanceTarget", event)}
        value={this.props.state.distanceTarget}
        input={<Input name="distanceTarget" id="distanceTarget-label-placeholder" />}
        displayEmpty="true"
        name="distanceTarget"
      >
      {options && options.length && options.map((option, i) => {
          return <MenuItem value={option.value} key={i}>{option.label}</MenuItem>
      })}
      </Select>
  </FormControl>
</Grid>

鉴于熊猫数据框df，我需要选择那些只有正值的列。

df =
  Age    Fare     Dev
  21     10        -1
  35     9        0
  28     12       1

我的第一个想法是使用df.describe()然后只选择那些最小值大于或等于 0 的列。但我在实现上陷入了困境。显然row.columns不起作用，因为 Series 没有columns属性。

properties = df.describe()
positive_cols = []
for index,row in properties.iterrows():
    for col in row.columns:
        print(col)

我在ReactJs调用中创建了一个主要组件MainPage（使用 Material-UI）。

import React from 'react';
import Grid from '@material-ui/core/Grid';
import Button from '@material-ui/core/Button';
import CssBaseline from '@material-ui/core/CssBaseline';
import Card from '@material-ui/core/Card';
import CardContent from '@material-ui/core/CardContent';
import withStyles from '@material-ui/core/styles/withStyles';

const styles = theme => ({
    card: {
        minWidth: 350,
    },
    button: {
        fontSize: '12px',
        margin: theme.spacing.unit,
        minWidth: 350
    },
    extendedIcon: {
        marginRight: theme.spacing.unit,
    }
});

class MainPage extends React.Component {
    constructor() {
        super();
    }

    render() {
        const {
            classes
        } = this.props;

        return ( < …

当我df.show()打印 DataFrame 行的内容时，出现此错误：

Caused by: com.fasterxml.jackson.databind.JsonMappingException: Incompatible Jackson version: 2.8.9
    at com.fasterxml.jackson.module.scala.JacksonModule$class.setupModule(JacksonModule.scala:64)
    at com.fasterxml.jackson.module.scala.DefaultScalaModule.setupModule(DefaultScalaModule.scala:19)
    at com.fasterxml.jackson.databind.ObjectMapper.registerModule(ObjectMapper.java:747)
    at org.apache.spark.rdd.RDDOperationScope$.<init>(RDDOperationScope.scala:82)
    at org.apache.spark.rdd.RDDOperationScope$.<clinit>(RDDOperationScope.scala)

这就是我创建的方式df：

object Test extends App {

   val spark = SparkSession.builder()
      .config("es.nodes", "XXX.XX.XX.XX")
      .config("es.port", "9200")
      .config("es.nodes.wan.only", "false")
      .config("es.resource","myIndex")
      .appName("Test")
      .master("local[*]")
      .getOrCreate()

   val df_source = spark
                   .read.format("org.elasticsearch.spark.sql")
                   .option("pushdown", "true")
                   .load("myIndex")

   df_source.show(5)

}

我不在我的build.sbt.

更新：

import sbtassembly.AssemblyPlugin.autoImport.assemblyOption
name := "test"
lazy val spark = "org.apache.spark"
lazy val typesafe = "com.typesafe.akka"
val sparkVersion = "2.2.0"
val elasticSparkVersion = …

这是我的熊猫数据帧：

Area            Gender  Quantity
XXX             Men     115
XXX             Men     105    
XXX             Men     114
YYY             Men     100
YYY             Men     90    
YYY             Men     95
YYY             Men     101
XXX             Women   120    
XXX             Women   122
XXX             Women   115
XXX             Women   117    
YYY             Women   91
YYY             Women   90
YYY             Women   90

这就是我创建箱线图的方式。

import seaboard as sns
import matplotlib.pyplot as pat

fig, ax = plt.subplots(figsize=(15,11))
ax = sns.boxplot(x="Area", y="Quantity", hue="Gender", data=df, palette="Set3")

我想Area按Quantity递增顺序按中位数对组进行排序。我该怎么做？

我有以下功能:

 def getData(spark: SparkSession,
             indices: Option[String]): Option[DataFrame] = {

    indices.map{
      ind =>
        spark
          .read
          .format("org.elasticsearch.spark.sql")
          .load(ind)
    }

  }

此函数返回Option[DataFrame].

然后我想使用这个函数如下:

val df = getData(spark, indices)
df.persist(StorageLevel.MEMORY_AND_DISK)

当然最后两行代码不会编译,因为df可能是None.None在Scala中处理输出的惯用方法是什么？我想抛出异常并停止程序,如果df是None.否则我想要persist它.

我有以下代码生成嵌套字典.

import random
import numpy as np

dict1 = {}
for i in range(0,2):
    dict2 = {}
    for j in range(0,3):
        dict2[j] = random.randint(1,10)
    dict1[i] = dict2

例如,它可以生成以下内容dict1:

{0: {0: 7, 1: 2, 2: 5}, 1: {0: 3, 1: 10, 2: 10}}

我想找到固定密钥的最小值的子密钥.例如,对于固定密钥0,嵌套字典值中的最小值是2指子密钥1.因此结果应该是1:

result=find_min(dict1[0])
result
1

我该如何开发这样的find_min功能？